home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update21.zoo / lib / diffc < prev    next >
Encoding:
Text File  |  1992-06-03  |  88.9 KB  |  3,926 lines
  1. *** 1.74    1992/04/19 16:02:45
  2. --- Changelo    1992/06/03 14:47:44
  3. ***************
  4. *** 3067,3069 ****
  5. --- 3067,3171 ----
  6.       find stuff in such PATH's (like when using findfile).
  7.   
  8.   ---------------------------- Patchlevel 80 ---------------------------
  9. + 
  10. + bcopy.s:: michal
  11. +     I looked at this new bcopy from the latest update and decided to check
  12. +     if it is faster only theoretically or maybe also in practice.  Reason
  13. +     beeing that my friend claimed that he tried a similar code on TT and
  14. +     after much coding it was actually slower.  So I got curious.  Well, at
  15. +     least on my Mega it is faster.  For some cases significantly so.
  16. +     Although nearly twice as big as the previous one.  Still I found that
  17. +     a small change speeds it up BUT in my experiments only for misaligned
  18. +     data.  In such situations I got up to 10% shorter times for a little
  19. +     bit longer data (break-even seems to be around 25 bytes; for
  20. +     smaller sizes the modified code is a tad slower but differences in timing
  21. +     are truly neglibible).  I still wonder why a similar change in a loop
  22. +     control for aligned data did not bring any real speed variations.
  23. +     
  24. +     Another surprise - two tests with branches for the last three
  25. +     bytes are actually better than a tight dbra loop.  This may look
  26. +     quite a bit different on a small instruction cache of 68020.
  27. + 
  28. +     [ jrb: yes, also it will be interesting to see the difference on
  29. +     68k's with loop-mode (is the 010 the only one??)].
  30. + 
  31. + localtim.c:: ++jrb
  32. +     rename dst to _dst and make it non-static. timeoday.c uses it.
  33. + 
  34. + ctype.c:: ++jrb
  35. +     break out toupper(), tolower() into seperate file so that
  36. +     users can re-define these and yet pull in ctype stuff, whout
  37. +     clashing.  (me2 does this).
  38. + 
  39. + toxxx.c:: +=jrb
  40. +     new file comtaining toupper()/tolower()
  41. + 
  42. + mincl:: ++jrb
  43. +     add target for toxxx.o
  44. + 
  45. + mintbind.h:: ++jrb
  46. +     add def for Psigpause() per MiNT 0.95 pl 1
  47. + 
  48. + osbind.h: ers
  49. +     Bconmap should be XBIOS call 0x2c, *not* 0x2b.
  50. +     0x2b is DMAwrite. There's obviously a potential for serious
  51. +     lossage here :-(. (mntlib has the same bug)
  52. + 
  53. + doprnt.c:: ers
  54. +     -- conditionalize prototypes so Sozobon can compile this
  55. +     -- use "+Inf", "-Inf", "NaN" instead of " Infinity ",
  56. +         " -Infinity ", and " Not A Number ". I'm told that
  57. +         ANSI specifies the shorter strings, and some programs
  58. +         rely on these.
  59. + 
  60. + *.h and some *.c:: ers/++jrb
  61. +     merge mntlib and lib headers. a few .c files needed adjustments
  62. +         because of this.
  63. + 
  64. + obstack.c/obstack.h:: ++jrb
  65. +     sanitize the ones from gcc 2.1 distribution for 16/32 ints and
  66. +         add to lib.
  67. + 
  68. + mincl:: ++jrb
  69. +     add target for obstack.c
  70. + 
  71. + bzero/bcmp/bcopy string.h:: ++jrb
  72. +         get rid of the silly old lbXXX aliases.
  73. +         add the MiNT _bxxx() aliases. should be useful with people like
  74. +         the soz 1.33 author who dont distinguish between an int and the size
  75. +         of an addressable object (under the guise of efficiency). big sigh!
  76. + 
  77. + malloc.c:: ++jrb
  78. +     split off realloc and calloc into their own files. put common
  79. +     definitions in lib.h so that it may be included in realloc.c
  80. +     and calloc.c.
  81. + 
  82. + realloc.c/calloc.c:: ++jrb
  83. +     new files.
  84. + 
  85. + mincl:: ++jrb
  86. +     add targets for realloc.o and calloc.o
  87. + 
  88. + lib.h:: ++jrb
  89. +     add common alloc defs
  90. +     cleanup
  91. + 
  92. + mincl: ++jrb
  93. +     in all the rules, change any explicitly specified source filename
  94. +     to $<, so that when VPATH is set the correct thing happens.
  95. + 
  96. + ---------------------------- Patchlevel 80.5 ---------------------------
  97. + *:: ers/++jrb
  98. +     start of merge of mnt/tos libs. all headers done. lots
  99. +     of common files done. lots of minor adjustments all
  100. +     over.
  101. + 
  102. + console.c:: scott
  103. +         We were doning a dev=LOOKUP(handle) in console_write_byte, than again
  104. +         in flush_key_buff()
  105. + 
  106. + eprintf.c:: ++jrb
  107. +     turn say into a routine that calculates the strlen. there was already
  108. +     a mistake there.
  109. + 
  110. + ---------------------------- Patchlevel 81 ---------------------------
  111. *** 1.56    1992/04/13 15:50:45
  112. --- PatchLev.h    1992/06/03 14:46:15
  113. ***************
  114. *** 1,5 ****
  115.   
  116. ! #define    PatchLevel "80"
  117.   
  118.   /*
  119.    *
  120. --- 1,5 ----
  121.   
  122. ! #define    PatchLevel "81"
  123.   
  124.   /*
  125.    *
  126. *** 1.14    1992/02/04 17:11:06
  127. --- close.c    1992/06/03 14:46:17
  128. ***************
  129. *** 8,13 ****
  130. --- 8,14 ----
  131.   #include    <fcntl.h>
  132.   #include    <device.h>
  133.   #include    <stdlib.h>
  134. + #include     <unistd.h>
  135.   
  136.   int (*pipeclose_p) __PROTO((int fd)) = 0;
  137.   
  138. *** 1.12    1992/04/13 15:50:45
  139. --- console.c    1992/06/03 14:46:17
  140. ***************
  141. *** 165,177 ****
  142.   int n;
  143.   {
  144.       char ch;
  145. -     short dev;
  146.   
  147. -     dev = LOOKUP(handle);
  148. - 
  149.       if (__check_signals)
  150. !         flush_key_buff(dev);
  151. ! /*    raw_out(dev, n); */
  152.       ch = n;
  153.       (void)Fwrite(handle, 1L, &ch);
  154.   }
  155. --- 165,173 ----
  156.   int n;
  157.   {
  158.       char ch;
  159.   
  160.       if (__check_signals)
  161. !         flush_key_buff(handle);
  162.       ch = n;
  163.       (void)Fwrite(handle, 1L, &ch);
  164.   }
  165. ***************
  166. *** 199,210 ****
  167.           ch = c & 0xff;
  168.           if (ch == ('S'-'@')) { waiting = 1; }
  169.           else if (ch == ('Q'-'@')) { waiting = 0; }
  170. !         else if (ch == __tchars[TC_INTRC]) 
  171.           { 
  172.           p->head = p->tail;
  173.           raise(SIGINT);
  174.           }
  175. !         else if (ch == __tchars[TC_QUITC]) 
  176.           { 
  177.           p->head = p->tail;
  178.           raise(SIGQUIT);
  179. --- 195,206 ----
  180.           ch = c & 0xff;
  181.           if (ch == ('S'-'@')) { waiting = 1; }
  182.           else if (ch == ('Q'-'@')) { waiting = 0; }
  183. !         else if (ch == (unsigned char)__tchars[TC_INTRC]) 
  184.           { 
  185.           p->head = p->tail;
  186.           raise(SIGINT);
  187.           }
  188. !         else if (ch == (unsigned char)__tchars[TC_QUITC]) 
  189.           { 
  190.           p->head = p->tail;
  191.           raise(SIGQUIT);
  192. *** 1.19    1992/04/19 16:02:45
  193. --- mincl    1992/06/03 14:46:21
  194. ***************
  195. *** 18,40 ****
  196.       bblink.o
  197.   #
  198.   # ANSI stuff + support
  199. ! ANSI =  atol.o atof.o abort.o bsearch.o clock.o ctime.o ctype.o difftime.o \
  200.       fopen.o fclose.o fdopen.o fflush.o fgetc.o fgets.o \
  201.       fputc.o fputs.o fread.o fwrite.o fseek.o fsetpos.o \
  202. !     fprintf.o sprintf.o \
  203.       fscanf.o scanf.o sscanf.o \
  204.       getenv.o putenv.o gets.o getw.o localtim.o \
  205. !     malloc.o qsort.o raise.o rand.o setbuf.o setvbuf.o \
  206.       setlocal.o strftime.o strtol.o system.o \
  207.       tmpnam.o tmpfile.o \
  208.       ltoa.o main.o doprnt.o div.o \
  209. !     strtoul.o fungetc.o filbuf.o getbuf.o
  210.   
  211.   #
  212.   # other portable stuff
  213.   PORT =  alphasor.o abs.o catch.o dirent.o findfile.o ftw.o getpw.o \
  214.       getlogin.o getopt.o getpass.o ident.o mktemp.o scandir.o strlwr.o \
  215. !     strrev.o regexp.o regsup.o textio.o random.o
  216.   
  217.   #
  218.   # the string library
  219. --- 18,42 ----
  220.       bblink.o
  221.   #
  222.   # ANSI stuff + support
  223. ! ANSI =  atol.o atof.o abort.o bsearch.o \
  224. !     calloc.o clock.o ctime.o ctype.o difftime.o \
  225.       fopen.o fclose.o fdopen.o fflush.o fgetc.o fgets.o \
  226.       fputc.o fputs.o fread.o fwrite.o fseek.o fsetpos.o \
  227. !     fprintf.o eprintf.o sprintf.o \
  228.       fscanf.o scanf.o sscanf.o \
  229.       getenv.o putenv.o gets.o getw.o localtim.o \
  230. !     malloc.o qsort.o raise.o rand.o realloc.o \
  231. !     setbuf.o setvbuf.o \
  232.       setlocal.o strftime.o strtol.o system.o \
  233.       tmpnam.o tmpfile.o \
  234.       ltoa.o main.o doprnt.o div.o \
  235. !     strtoul.o fungetc.o filbuf.o getbuf.o toxxx.o
  236.   
  237.   #
  238.   # other portable stuff
  239.   PORT =  alphasor.o abs.o catch.o dirent.o findfile.o ftw.o getpw.o \
  240.       getlogin.o getopt.o getpass.o ident.o mktemp.o scandir.o strlwr.o \
  241. !     strrev.o regexp.o regsup.o textio.o random.o obstack.o
  242.   
  243.   #
  244.   # the string library
  245. ***************
  246. *** 74,84 ****
  247.   #
  248.   # osbind.o/gmon.o/fork.o CANNOT have -fomit-frame-pointer
  249.   osbind.o: osbind.c
  250. !     $(CC) $(CFFLAGS) -c osbind.c
  251.   gmon.o: gmon.c
  252. !     $(CC) $(CFFLAGS) -c gmon.c
  253.   fork.o: fork.c
  254. !     $(CC) $(CFFLAGS) -c fork.c
  255.   
  256.   #
  257.   # Assembler stuff that needs to be preprocessed by cpp into a .S
  258. --- 76,86 ----
  259.   #
  260.   # osbind.o/gmon.o/fork.o CANNOT have -fomit-frame-pointer
  261.   osbind.o: osbind.c
  262. !     $(CC) $(CFFLAGS) -c $<
  263.   gmon.o: gmon.c
  264. !     $(CC) $(CFFLAGS) -c $<
  265.   fork.o: fork.c
  266. !     $(CC) $(CFFLAGS) -c $<
  267.   
  268.   #
  269.   # Assembler stuff that needs to be preprocessed by cpp into a .S
  270. ***************
  271. *** 111,124 ****
  272.   #
  273.   # integer only io stuff
  274.   idoprnt.o: doprnt.c
  275. !     $(CC) $(CFLAGS) -D__NO_FLOAT__ -c doprnt.c -o idoprnt.o
  276.   
  277.   iscanf.o: scanf.c
  278. !     $(CC) $(CFLAGS) -D__NO_FLOAT__ -c scanf.c -o iscanf.o
  279.   
  280.   # gcrt0
  281.   gcrt0.o: crt0.c
  282. !     $(CC) $(CFLAGS) -D__GCRT0__ -c crt0.c -o gcrt0.o
  283.   
  284.   # other dependencies
  285.   bcopy.o : bcopy.s
  286. --- 113,126 ----
  287.   #
  288.   # integer only io stuff
  289.   idoprnt.o: doprnt.c
  290. !     $(CC) $(CFLAGS) -D__NO_FLOAT__ -c $< -o idoprnt.o
  291.   
  292.   iscanf.o: scanf.c
  293. !     $(CC) $(CFLAGS) -D__NO_FLOAT__ -c $< -o iscanf.o
  294.   
  295.   # gcrt0
  296.   gcrt0.o: crt0.c
  297. !     $(CC) $(CFLAGS) -D__GCRT0__ -c $< -o gcrt0.o
  298.   
  299.   # other dependencies
  300.   bcopy.o : bcopy.s
  301. *** 1.11    1992/04/13 15:50:45
  302. --- mkdir.c    1992/06/03 14:46:21
  303. ***************
  304. *** 15,21 ****
  305.   
  306.   int mkdir(_path, mode)
  307.   const char *_path;
  308. ! int mode;
  309.   {
  310.       int rv, name_munged;
  311.       char path[FILENAME_MAX];
  312. --- 15,21 ----
  313.   
  314.   int mkdir(_path, mode)
  315.   const char *_path;
  316. ! unsigned int mode;
  317.   {
  318.       int rv, name_munged;
  319.       char path[FILENAME_MAX];
  320. *** 1.18    1992/04/13 15:50:45
  321. --- stat.c    1992/06/03 14:46:24
  322. ***************
  323. *** 37,43 ****
  324.   DIR *__opendir_chain = 0;    /* chain of open directories from opendir */
  325.   
  326.   /* date for files (like root directories) that don't have one */
  327. ! #define OLDDATE unixtime(0,0)
  328.   
  329.   /*
  330.    * check file cache for the file whose canonical (unx2dos) name is fullname.
  331. --- 37,43 ----
  332.   DIR *__opendir_chain = 0;    /* chain of open directories from opendir */
  333.   
  334.   /* date for files (like root directories) that don't have one */
  335. ! #define OLDDATE _unixtime(0,0)
  336.   
  337.   /*
  338.    * check file cache for the file whose canonical (unx2dos) name is fullname.
  339. ***************
  340. *** 184,190 ****
  341.           return -1;
  342.       }
  343.       st->st_mtime = st->st_ctime = st->st_atime =
  344. !         unixtime(d->d_time, d->d_date);
  345.       st->st_ino = d->d_ino;
  346.       st->st_attr = d->d_attribute;
  347.       st->st_mode = 0644 | (d->d_attribute & FA_DIR ?
  348. --- 184,190 ----
  349.           return -1;
  350.       }
  351.       st->st_mtime = st->st_ctime = st->st_atime =
  352. !         _unixtime(d->d_time, d->d_date);
  353.       st->st_ino = d->d_ino;
  354.       st->st_attr = d->d_attribute;
  355.       st->st_mode = 0644 | (d->d_attribute & FA_DIR ?
  356. ***************
  357. *** 289,295 ****
  358.           long oldplace;
  359.           
  360.           st->st_mtime = st->st_atime = st->st_ctime =
  361. !             unixtime(timestruct.time,timestruct.date);
  362.           st->st_mode = S_IFREG | 0644;        /* this may be false */
  363.           st->st_attr = 0;            /* because this is */
  364.           
  365. --- 289,295 ----
  366.           long oldplace;
  367.           
  368.           st->st_mtime = st->st_atime = st->st_ctime =
  369. !             _unixtime(timestruct.time,timestruct.date);
  370.           st->st_mode = S_IFREG | 0644;        /* this may be false */
  371.           st->st_attr = 0;            /* because this is */
  372.           
  373. *** 1.22    1992/04/19 16:02:45
  374. --- unx2dos.c    1992/06/03 14:46:26
  375. ***************
  376. *** 6,11 ****
  377. --- 6,12 ----
  378.   #include <types.h>
  379.   #include <dirent.h>
  380.   #include "symdir.h"
  381. + #include "lib.h"
  382.   #ifndef _COMPILER_H
  383.   #include <compiler.h>
  384.   #endif
  385. ***************
  386. *** 607,613 ****
  387.    */
  388.   
  389.   /* system default file name mapping function pointers */
  390. - typedef int (*fnmapfunc_t)(const char *, char *);
  391.   
  392.   static fnmapfunc_t ux2dos = _unx2dos;
  393.   static fnmapfunc_t dos2ux = _dos2unx;
  394. --- 608,613 ----
  395. *** 1.1    1992/04/06 19:33:32
  396. --- _fltsi.cpp    1992/06/03 14:49:07
  397. ***************
  398. *** 12,20 ****
  399.   
  400.   __floatsidf:
  401.   ___floatsidf:
  402. !     fmovel    a7@(4),fp0        | load long int to fp0
  403. !     fintrzd a4@(4),fp0        | get double from fp0
  404. !     fmoved    fp0,a7@-
  405.       moveml    a7@+,d0-d1
  406.        rts
  407.   
  408. --- 12,19 ----
  409.   
  410.   __floatsidf:
  411.   ___floatsidf:
  412. !     fintrzd a7@(4),fp0        | load long int to fp0
  413. !     fmoved    fp0,a7@-        | get double from fp0
  414.       moveml    a7@+,d0-d1
  415.        rts
  416.   
  417. *** 1.4    1991/04/26 03:42:08
  418. --- abort.c    1992/06/03 14:49:09
  419. ***************
  420. *** 1,8 ****
  421.   /* ERS */
  422.   
  423. - #include <stddef.h>
  424. - #include <stdlib.h>
  425.   #include <signal.h>
  426.   #include <unistd.h>
  427.   
  428.   #ifndef SIGABRT
  429. --- 1,7 ----
  430.   /* ERS */
  431.   
  432.   #include <signal.h>
  433. + #include <stdlib.h>
  434.   #include <unistd.h>
  435.   
  436.   #ifndef SIGABRT
  437. ***************
  438. *** 10,20 ****
  439.   #endif
  440.   
  441.   __EXITING abort()
  442. !     {
  443. ! #if 0 /* for now */
  444.       raise(SIGABRT);
  445. ! #else
  446. !     raise(SIGIOT);
  447. ! #endif
  448. !     exit(-999);
  449. !     }
  450. --- 9,15 ----
  451.   #endif
  452.   
  453.   __EXITING abort()
  454. ! {
  455.       raise(SIGABRT);
  456. !     exit(127);
  457. ! }
  458. *** 1.7    1991/04/12 18:19:53
  459. --- access.c    1992/06/03 14:49:09
  460. ***************
  461. *** 4,10 ****
  462. --- 4,13 ----
  463.   #include <stat.h>
  464.   #include <fcntl.h>
  465.   #include <errno.h>
  466. + #include <unistd.h>
  467.   
  468. + extern int __mint;
  469. + 
  470.   int
  471.   access(path, mode)
  472.       const char *path;
  473. ***************
  474. *** 11,16 ****
  475. --- 14,20 ----
  476.       int mode;
  477.   {
  478.       struct stat sb;
  479. +     int uid, gid;
  480.   
  481.       if (stat(path, &sb) < 0)
  482.           return -1;    /* errno was set by stat() */
  483. ***************
  484. *** 20,27 ****
  485.   /* somewhat crufty code -- relies on R_OK, etc. matching the bits in the
  486.      file mode, but what the heck, we can do this
  487.    */
  488. !     if ( ((sb.st_mode >> 6) & mode) == mode )
  489. !         return 0;
  490.   
  491.       errno = EACCESS; return -1;
  492.   }
  493. --- 24,45 ----
  494.   /* somewhat crufty code -- relies on R_OK, etc. matching the bits in the
  495.      file mode, but what the heck, we can do this
  496.    */
  497. !     if (__mint < 9 || ( (uid = geteuid()) == sb.st_uid ) ) {
  498. !         if ( ((sb.st_mode >> 6) & mode) == mode )
  499. !             return 0;
  500. !         else
  501. !             goto accdn;
  502. !     }
  503.   
  504. +     if ( (gid = getegid()) == sb.st_gid ) {
  505. +         if ( ((sb.st_mode >> 3) & mode) == mode )
  506. +             return 0;
  507. +         else
  508. +             goto accdn;
  509. +     }
  510. + 
  511. +     if ( (sb.st_mode & mode) == mode)
  512. +         return 0;
  513. + accdn:
  514.       errno = EACCESS; return -1;
  515.   }
  516. *** 1.5    1992/04/13 15:50:45
  517. --- alloca.s    1992/06/03 14:49:09
  518. ***************
  519. *** 19,24 ****
  520.       subl    d0,sp        | increase stack frame size by that much
  521.       movel    sp,d0        | set up to return it
  522.   
  523. !     subql    #4,sp        | new top of stack (real bug fix here)
  524.   
  525.       jmp    a0@        | return by jmping via saved addr
  526. --- 19,24 ----
  527.       subl    d0,sp        | increase stack frame size by that much
  528.       movel    sp,d0        | set up to return it
  529.   
  530. !     lea    sp@(-4),sp    | new top of stack (real bug fix here)
  531.   
  532.       jmp    a0@        | return by jmping via saved addr
  533. *** 1.10    1992/03/06 19:19:47
  534. --- bcmp.c    1992/06/03 14:49:10
  535. ***************
  536. *** 3,10 ****
  537.   #include <assert.h>
  538.   
  539.   #undef ODD
  540. ! #define ODD(x) (((short)(x)) & 1)    /* word ops are faster */
  541. ! #define INC(x, size) x = (const void *)(((const char *)(x)) + (size))
  542.   
  543.   /*
  544.    * compare n bytes efficientlty
  545. --- 3,9 ----
  546.   #include <assert.h>
  547.   
  548.   #undef ODD
  549. ! #define ODD(x) (((long)(x)) & 1)
  550.   
  551.   /*
  552.    * compare n bytes efficientlty
  553. ***************
  554. *** 13,19 ****
  555.    *
  556.    *   ++jrb  bammi@dsrgsun.ces.cwru.edu
  557.    */
  558. ! asm(".stabs \"_lbcmp\",5,0,0,_bcmp"); /* dept of clean tricks */
  559.   
  560.   int bcmp(src, dst, n)
  561.   const void * src;
  562. --- 12,19 ----
  563.    *
  564.    *   ++jrb  bammi@dsrgsun.ces.cwru.edu
  565.    */
  566. ! 
  567. ! #define INC(x, size) x = (const void *)(((const char *)(x)) + (size))
  568.   
  569.   int bcmp(src, dst, n)
  570.   const void * src;
  571. ***************
  572. *** 20,25 ****
  573. --- 20,26 ----
  574.   const void * dst;
  575.   register size_t n;
  576.   {
  577. + 
  578.       assert ((src != NULL) && (dst != NULL));
  579.   
  580.       if((src != dst) && (n > 0))
  581. *** 1.5    1992/04/13 15:50:45
  582. --- bcopy.s    1992/06/03 14:49:11
  583. ***************
  584. *** 3,14 ****
  585.   |    handles overlap, odd/even alignment
  586.   |    uses movem to copy 256 bytes blocks faster.
  587.   |    Alexander Lehmann    alexlehm@iti.informatik.th-darmstadt.de
  588. ! |    sortof inspired by jrb's bcopy
  589.   
  590.       .text
  591.       .even
  592.       .globl _bcopy
  593. !     .globl _lbcopy
  594.       .globl _memcpy
  595.       .globl _memmove
  596.   
  597. --- 3,14 ----
  598.   |    handles overlap, odd/even alignment
  599.   |    uses movem to copy 256 bytes blocks faster.
  600.   |    Alexander Lehmann    alexlehm@iti.informatik.th-darmstadt.de
  601. ! |    sortof inspired by jrbs bcopy
  602.   
  603.       .text
  604.       .even
  605.       .globl _bcopy
  606. !     .globl    __bcopy
  607.       .globl _memcpy
  608.       .globl _memmove
  609.   
  610. ***************
  611. *** 29,35 ****
  612.   |    functions are aliased
  613.   
  614.   _bcopy:
  615. ! _lbcopy:
  616.       movl    sp@(4),a0    | src
  617.       movl    sp@(8),a1    | dest
  618.   common:    movl    sp@(12),d0    | length
  619. --- 29,35 ----
  620.   |    functions are aliased
  621.   
  622.   _bcopy:
  623. ! __bcopy:
  624.       movl    sp@(4),a0    | src
  625.       movl    sp@(8),a1    | dest
  626.   common:    movl    sp@(12),d0    | length
  627. ***************
  628. *** 49,55 ****
  629.       jne    slow_copy
  630.       btst    #0,d2        | both even ?
  631.       jeq    both_even
  632. !     movb    a0@+,a1@+    | copy one byte, now we're both even
  633.       subql    #1,d0
  634.   both_even:
  635.       clrw    d1        | save length less 256
  636. --- 49,55 ----
  637.       jne    slow_copy
  638.       btst    #0,d2        | both even ?
  639.       jeq    both_even
  640. !     movb    a0@+,a1@+    | copy one byte, now we are both even
  641.       subql    #1,d0
  642.   both_even:
  643.       clrw    d1        | save length less 256
  644. *** 1.7    1991/04/26 03:42:08
  645. --- bsearch.c    1992/06/03 14:49:11
  646. ***************
  647. *** 30,36 ****
  648.       while(a <= b)
  649.           {
  650.           c = (a + b) >> 1;    /* == ((a + b) / 2) */
  651. !         if (dir = (*cmp)((void *)((char *)base + c * size), key))
  652.               {
  653.               if (dir > 0)
  654.               {
  655. --- 30,36 ----
  656.       while(a <= b)
  657.           {
  658.           c = (a + b) >> 1;    /* == ((a + b) / 2) */
  659. !         if (dir = (*cmp)((void *)((char *)base + (c * size)), key))
  660.               {
  661.               if (dir > 0)
  662.               {
  663. *** 1.1    1992/04/06 19:33:32
  664. --- bzero.cpp    1992/06/03 14:49:11
  665. ***************
  666. *** 1,4 ****
  667. - 
  668.   |    new version of bcopy and memset
  669.   |    uses movem to set 256 bytes blocks faster.
  670.   |    Alexander Lehmann    alexlehm@iti.informatik.th-darmstadt.de
  671. --- 1,3 ----
  672. ***************
  673. *** 8,14 ****
  674.       .text
  675.       .even
  676.       .globl _bzero
  677. !     .globl _lbzero
  678.       .globl _memset
  679.   
  680.   |    void *memset( void *dest, int val, size_t len );
  681. --- 7,13 ----
  682.       .text
  683.       .even
  684.       .globl _bzero
  685. !     .globl __bzero
  686.       .globl _memset
  687.   
  688.   |    void *memset( void *dest, int val, size_t len );
  689. ***************
  690. *** 28,38 ****
  691.       jra    do_set
  692.   
  693.   |    void bzero( void *dest, size_t length );
  694. ! |    void lbzero( void *dest, size_t length );
  695.   |    return value not used (returns dest)
  696.   
  697.   _bzero:
  698. ! _lbzero:
  699.       movl    sp@(4),a0    | dest
  700.       movl    sp@(8),d1    | length
  701.       jeq    exit        | length==0? (size_t)
  702. --- 27,37 ----
  703.       jra    do_set
  704.   
  705.   |    void bzero( void *dest, size_t length );
  706. ! |    void _bzero( void *dest, size_t length );
  707.   |    return value not used (returns dest)
  708.   
  709.   _bzero:
  710. ! __bzero:
  711.       movl    sp@(4),a0    | dest
  712.       movl    sp@(8),d1    | length
  713.       jeq    exit        | length==0? (size_t)
  714. *** 1.9    1991/06/11 23:04:27
  715. --- chdir.c    1992/06/03 14:49:12
  716. ***************
  717. *** 1,9 ****
  718. - #include <stdio.h>
  719.   #include <errno.h>
  720.   #include <osbind.h>
  721.   #include <stddef.h>
  722.   #include <assert.h>
  723.   #include <ctype.h>
  724.   #include <unistd.h>
  725.   #include "lib.h"
  726.   
  727. --- 1,9 ----
  728.   #include <errno.h>
  729.   #include <osbind.h>
  730.   #include <stddef.h>
  731.   #include <assert.h>
  732.   #include <ctype.h>
  733. + #include <limits.h>
  734.   #include <unistd.h>
  735.   #include "lib.h"
  736.   
  737. ***************
  738. *** 17,23 ****
  739.   {
  740.       int drv, old;
  741.       int r;
  742. !     char tmp[FILENAME_MAX];
  743.       register char *d;
  744.   
  745.       assert ((dir != NULL));
  746. --- 17,23 ----
  747.   {
  748.       int drv, old;
  749.       int r;
  750. !     char tmp[PATH_MAX];
  751.       register char *d;
  752.   
  753.       assert ((dir != NULL));
  754. *** 1.5    1991/06/11 23:04:27
  755. --- chmod.c    1992/06/03 14:49:12
  756. ***************
  757. *** 5,16 ****
  758.   #include <types.h>
  759.   #include <stat.h>
  760.   #include <osbind.h>
  761. ! #include <stdio.h>
  762.   #include <errno.h>
  763.   #include <unistd.h>
  764. - #include <support.h>
  765.   #include "lib.h"
  766.   
  767.   
  768.   int chmod(_path, mode)
  769.          const char *_path;
  770. --- 5,17 ----
  771.   #include <types.h>
  772.   #include <stat.h>
  773.   #include <osbind.h>
  774. ! #include <mintbind.h>
  775. ! #include <limits.h>
  776.   #include <errno.h>
  777.   #include <unistd.h>
  778.   #include "lib.h"
  779.   
  780. + extern int __mint;
  781.   
  782.   int chmod(_path, mode)
  783.          const char *_path;
  784. ***************
  785. *** 17,31 ****
  786.          int   mode;
  787.   {
  788.          int  dosattrib = 0, r;
  789. !        char path[FILENAME_MAX];
  790.          struct stat stb;
  791.   
  792.          (void)unx2dos(_path, path);
  793.   
  794. !     /* The following lines ensure that the archive bit isn't cleared */
  795. !         r = Fattrib(path, 0, dosattrib);
  796. !         if (r > 0 && (r & FA_CHANGED))
  797. !                 dosattrib |= FA_CHANGED;
  798.   #if 0
  799.          if (!(mode & S_IREAD))
  800.                  dosattrib |= FA_HIDDEN;
  801. --- 18,42 ----
  802.          int   mode;
  803.   {
  804.          int  dosattrib = 0, r;
  805. !        char path[PATH_MAX];
  806.          struct stat stb;
  807.   
  808.          (void)unx2dos(_path, path);
  809.   
  810. !     if (__mint >= 9) {    /* use MiNT Fchmod function */
  811. !         r = Fchmod(path, mode);
  812. !         if (r) {
  813. !             errno = -r;
  814. !             return -1;
  815. !         }
  816. !         return 0;
  817. !     }
  818. ! 
  819. ! /* The following lines ensure that the archive bit isn't cleared */
  820. !     r = Fattrib(path, 0, dosattrib);
  821. !      if (r > 0 && (r & FA_CHANGED))
  822. !         dosattrib |= FA_CHANGED;
  823. ! 
  824.   #if 0
  825.          if (!(mode & S_IREAD))
  826.                  dosattrib |= FA_HIDDEN;
  827. ***************
  828. *** 45,55 ****
  829.          return 0;
  830.   }
  831.   
  832. ! /* just fake these for now */
  833.   
  834. ! int chown(name, uid, gid)
  835. !        const char *name;
  836.          int uid, gid;
  837.   {
  838. !        return 0;
  839.   }
  840. --- 56,80 ----
  841.          return 0;
  842.   }
  843.   
  844. ! /*
  845. !  * chown: this is faked if MiNT is not running
  846. !  */
  847.   
  848. ! int chown(_name, uid, gid)
  849. !        const char *_name;
  850.          int uid, gid;
  851.   {
  852. !     int r;
  853. !     char name[PATH_MAX];
  854. ! 
  855. !     if (__mint >= 9) {
  856. !         (void)unx2dos(_name, name);
  857. !         r = Fchown(name, uid, gid);
  858. !         if (r) {
  859. !             errno = -r;
  860. !             return -1;
  861. !         }
  862. !         return 0;
  863. !     }
  864. !     return 0;
  865.   }
  866. *** 1.7    1992/03/06 19:19:47
  867. --- ctype.c    1992/06/03 14:49:13
  868. ***************
  869. *** 65,79 ****
  870.       };
  871.   
  872.   unsigned char *_ctype = &(_myctype[0]);
  873. - 
  874. - int toupper(c)
  875. -     int c;
  876. -     {
  877. -     return(islower(c) ? (c ^ 0x20) : (c));
  878. -     }
  879. - 
  880. - int tolower(c)
  881. -     int c;
  882. -     {
  883. -     return(isupper(c) ? (c ^ 0x20) : (c));
  884. -     }
  885. --- 65,67 ----
  886. *** 1.14    1992/04/19 16:02:45
  887. --- doprnt.c    1992/06/03 14:49:14
  888. ***************
  889. *** 52,60 ****
  890. --- 52,62 ----
  891.   #include    <math.h>    /* mjr++    */
  892.   
  893.   #ifndef __GNUC__    /* gcc lib has these typedefs in sys/types.h */
  894. + #ifndef __MINT__    /* as does the MiNT library */
  895.   typedef unsigned char u_char;
  896.   typedef unsigned long u_long;
  897.   #endif
  898. + #endif
  899.   
  900.   /* 11-bit exponent (VAX G floating point) is 308 decimal digits */
  901.   #define    MAXEXP        308
  902. ***************
  903. *** 314,320 ****
  904.               if (_dd.i[0] == NAN_HI)
  905.               {
  906.                   t = buf;
  907. !                 t = strcpy(t, " Not A Number ");
  908.                   size = strlen(t);
  909.                   goto pforw;
  910.               }
  911. --- 316,322 ----
  912.               if (_dd.i[0] == NAN_HI)
  913.               {
  914.                   t = buf;
  915. !                 t = strcpy(t, "NaN");
  916.                   size = strlen(t);
  917.                   goto pforw;
  918.               }
  919. ***************
  920. *** 345,353 ****
  921.                 {
  922.                   t = buf;
  923.                   if(softsign == 0)
  924. !                 t = strcpy(t, " Infinity ");
  925.                   else
  926. !                 t = strcpy(t, " -Infinity ");
  927.                   size = strlen(t);
  928.                   goto pforw;
  929.               }
  930. --- 347,355 ----
  931.                 {
  932.                   t = buf;
  933.                   if(softsign == 0)
  934. !                 t = strcpy(t, "+Inf");
  935.                   else
  936. !                 t = strcpy(t, "-Inf");
  937.                   size = strlen(t);
  938.                   goto pforw;
  939.               }
  940. ***************
  941. *** 400,406 ****
  942.                    * NUL in the first `prec' characters, and
  943.                    * strlen() will go further.
  944.                    */
  945. ! #ifdef __GNUC__
  946.                   char *p;
  947.                   void *memchr(const void *, int, size_t);
  948.   #else
  949. --- 402,408 ----
  950.                    * NUL in the first `prec' characters, and
  951.                    * strlen() will go further.
  952.                    */
  953. ! #ifdef __STDC__
  954.                   char *p;
  955.                   void *memchr(const void *, int, size_t);
  956.   #else
  957. ***************
  958. *** 538,544 ****
  959.       register char *p, *t;
  960.       register double fract;
  961.       int dotrim, expcnt, gformat;
  962. !     double integer, tmp, modf(double, double *);
  963.       char *exponent __PROTO((char *, int, int)),
  964.            *round __PROTO((double, int *, char *, char *, int, char *));
  965.   
  966. --- 540,546 ----
  967.       register char *p, *t;
  968.       register double fract;
  969.       int dotrim, expcnt, gformat;
  970. !     double integer, tmp, modf __PROTO((double, double *));
  971.       char *exponent __PROTO((char *, int, int)),
  972.            *round __PROTO((double, int *, char *, char *, int, char *));
  973.   
  974. *** 1.7    1991/04/26 03:42:08
  975. --- fclose.c    1992/06/03 14:49:15
  976. ***************
  977. *** 4,9 ****
  978. --- 4,11 ----
  979.   #include <stdlib.h>
  980.   #include <unistd.h>
  981.   
  982. + extern int __mint;
  983. + 
  984.   int fclose(fp)
  985.       register FILE *fp;
  986.       {
  987. ***************
  988. *** 37,44 ****
  989.           }
  990.   #endif
  991.       fp->_flag = 0;            /* clear status */
  992. !     if(f & _IODEV)            /* leave tty's alone */
  993. !         return(0);
  994.       error |= close(fp->_file);
  995.       return(error ? EOF : 0);
  996.       }
  997. --- 39,47 ----
  998.           }
  999.   #endif
  1000.       fp->_flag = 0;            /* clear status */
  1001. !     if (__mint  == 0)
  1002. !         if(f & _IODEV)            /* leave tty's alone */
  1003. !             return(0);
  1004.       error |= close(fp->_file);
  1005.       return(error ? EOF : 0);
  1006.       }
  1007. *** 1.10    1992/03/06 19:19:47
  1008. --- fdopen.c    1992/06/03 14:49:15
  1009. ***************
  1010. *** 8,14 ****
  1011.   FILE *fdopen(h, mode)
  1012.       register int h;
  1013.       const register char *mode;
  1014. !     {
  1015.       extern int __default_mode__;    /* see binmode.c */
  1016.       register int i, iomode = 0, f = __default_mode__;
  1017.       register FILE *fp = NULL;
  1018. --- 8,14 ----
  1019.   FILE *fdopen(h, mode)
  1020.       register int h;
  1021.       const register char *mode;
  1022. ! {
  1023.       extern int __default_mode__;    /* see binmode.c */
  1024.       register int i, iomode = 0, f = __default_mode__;
  1025.       register FILE *fp = NULL;
  1026. ***************
  1027. *** 17,31 ****
  1028.       for(i=0; (!fp && (i < _NFILE)); ++i)
  1029.           if(!(_iob[i]._flag & (_IORW | _IOREAD | _IOWRT)))
  1030.               fp = &_iob[i];    /* empty slot */
  1031. !     if(!fp)
  1032. !       {
  1033. !         errno = EMFILE;
  1034. !         return(NULL);
  1035. !       }
  1036. !     while(*mode)
  1037. !         {
  1038. !         switch(*mode++)
  1039. !             {
  1040.               case 'r':
  1041.                   f |= _IOREAD;
  1042.                   break;
  1043. --- 17,29 ----
  1044.       for(i=0; (!fp && (i < _NFILE)); ++i)
  1045.           if(!(_iob[i]._flag & (_IORW | _IOREAD | _IOWRT)))
  1046.               fp = &_iob[i];    /* empty slot */
  1047. !     if(!fp) {
  1048. !         errno = EMFILE;
  1049. !         return(NULL);
  1050. !     }
  1051. ! 
  1052. !     while(*mode) {
  1053. !         switch(*mode++) {
  1054.               case 'r':
  1055.                   f |= _IOREAD;
  1056.                   break;
  1057. ***************
  1058. *** 47,56 ****
  1059.               case 't':
  1060.                   f &= ~_IOBIN;
  1061.                   break;
  1062. !             default:    /* Illegal file mode */
  1063.                   return(NULL);
  1064.               }
  1065. !         }
  1066.       if((i = (f & (_IORW | _IOREAD | _IOWRT))) == 0)
  1067.           return(NULL);
  1068.       else if(i == _IOREAD)
  1069. --- 45,54 ----
  1070.               case 't':
  1071.                   f &= ~_IOBIN;
  1072.                   break;
  1073. !             default:        /* illegal file mode */
  1074.                   return(NULL);
  1075.               }
  1076. !     }
  1077.       if((i = (f & (_IORW | _IOREAD | _IOWRT))) == 0)
  1078.           return(NULL);
  1079.       else if(i == _IOREAD)
  1080. ***************
  1081. *** 59,64 ****
  1082. --- 57,63 ----
  1083.           iomode |= O_WRONLY;
  1084.       else
  1085.           iomode |= O_RDWR;
  1086. + 
  1087.       if(isatty(h))
  1088.           f |= (_IODEV | _IONBF);
  1089.       else
  1090. ***************
  1091. *** 65,77 ****
  1092.           f |= _IOFBF;
  1093.       fp->_file = h;            /* file handle */
  1094.       fp->_flag = f;            /* file status flags */
  1095. - #if 0
  1096. -     fp->_base = NULL;        /* base of file buffer */
  1097. -     fp->_ptr = NULL;        /* current buffer pointer */
  1098. -     fp->_bsiz = 0;            /* buffer size */
  1099. -     fp->_cnt = 0;            /* # of bytes in buffer */
  1100. - #else
  1101.       _getbuf(fp);
  1102. - #endif
  1103.       return(fp);
  1104. !     }
  1105. --- 64,69 ----
  1106.           f |= _IOFBF;
  1107.       fp->_file = h;            /* file handle */
  1108.       fp->_flag = f;            /* file status flags */
  1109.       _getbuf(fp);
  1110.       return(fp);
  1111. ! }
  1112. *** 1.4    1991/04/12 18:19:53
  1113. --- fgets.c    1992/06/03 14:49:16
  1114. ***************
  1115. *** 13,19 ****
  1116.       register int c = EOF;
  1117.   
  1118.       assert((data != NULL));
  1119. !     
  1120.       while((--limit > 0) && ((c = getc(fp)) != EOF))
  1121.           if((*p++ = c) == '\n')
  1122.               break;
  1123. --- 13,19 ----
  1124.       register int c = EOF;
  1125.   
  1126.       assert((data != NULL));
  1127. ! 
  1128.       while((--limit > 0) && ((c = getc(fp)) != EOF))
  1129.           if((*p++ = c) == '\n')
  1130.               break;
  1131. *** 1.9    1991/12/26 15:53:59
  1132. --- findfile.c    1992/06/03 14:49:16
  1133. ***************
  1134. *** 9,22 ****
  1135.      Written by Eric R. Smith and placed in the public domain.
  1136.   */
  1137.   
  1138. ! #include <stdio.h>    /* needed only for FILENAME_MAX */
  1139.   #include <stddef.h>
  1140.   #include <types.h>
  1141.   #include <stat.h>
  1142.   #include <string.h>
  1143. - #ifndef _COMPILER_H
  1144. - #include <compiler.h>
  1145. - #endif
  1146.   
  1147.   /* characters used to separate components in a path list */
  1148.   #define PATHSEP1        ':'
  1149. --- 9,19 ----
  1150.      Written by Eric R. Smith and placed in the public domain.
  1151.   */
  1152.   
  1153. ! #include <limits.h>    /* needed for PATH_MAX */
  1154.   #include <stddef.h>
  1155.   #include <types.h>
  1156.   #include <stat.h>
  1157.   #include <string.h>
  1158.   
  1159.   /* characters used to separate components in a path list */
  1160.   #define PATHSEP1        ':'
  1161. ***************
  1162. *** 28,35 ****
  1163.   
  1164.   static char *nullext[] = { NULL };
  1165.   
  1166. - static int EXISTS __PROTO((char *name));
  1167. - 
  1168.   static int
  1169.   EXISTS(name)
  1170.       char *name;
  1171. --- 25,30 ----
  1172. ***************
  1173. *** 47,53 ****
  1174.   findfile(fname, fpath, fext)
  1175.           char *fname, *fpath, **fext;
  1176.   {
  1177. !         static char try[FILENAME_MAX];
  1178.           char *s, *t, *extplace, **nextext, c;
  1179.           int  hasext = 0, haspath = 0;
  1180.   
  1181. --- 42,48 ----
  1182.   findfile(fname, fpath, fext)
  1183.           char *fname, *fpath, **fext;
  1184.   {
  1185. !         static char try[PATH_MAX];
  1186.           char *s, *t, *extplace, **nextext, c;
  1187.           int  hasext = 0, haspath = 0;
  1188.   
  1189. *** 1.16    1992/01/29 20:58:29
  1190. --- fopen.c    1992/06/03 14:49:16
  1191. ***************
  1192. *** 5,13 ****
  1193.   #include <fcntl.h>
  1194.   #include <unistd.h>
  1195.   #include <errno.h>
  1196. - #ifndef _COMPILER_H
  1197. - #include <compiler.h>
  1198. - #endif
  1199.   
  1200.   __EXTERN void _getbuf __PROTO((FILE *));
  1201.   
  1202. --- 5,10 ----
  1203. ***************
  1204. *** 16,23 ****
  1205.   
  1206.   extern int __default_mode__;
  1207.   
  1208. - static FILE *_fopen __PROTO((const char *filename, const char *mode, FILE *fp));
  1209. - 
  1210.   static FILE *_fopen(filename, mode, fp)
  1211.       const char *filename;
  1212.       const register char *mode;
  1213. --- 13,18 ----
  1214. ***************
  1215. *** 54,60 ****
  1216.               case 't':
  1217.                   f &= ~_IOBIN;
  1218.                   break;
  1219. !             default:    /* Illegal file mode */
  1220.                   return(NULL);
  1221.               }
  1222.           }
  1223. --- 49,55 ----
  1224.               case 't':
  1225.                   f &= ~_IOBIN;
  1226.                   break;
  1227. !             default:
  1228.                   return(NULL);
  1229.               }
  1230.           }
  1231. ***************
  1232. *** 85,91 ****
  1233.       const char *filename, *mode;
  1234.       {
  1235.       register int i;
  1236. !         register FILE *fp = NULL;
  1237.   
  1238.       for(i=0; (!fp && (i < _NFILE)); ++i)
  1239.           if(!(_iob[i]._flag & (_IORW | _IOREAD | _IOWRT))) 
  1240. --- 80,86 ----
  1241.       const char *filename, *mode;
  1242.       {
  1243.       register int i;
  1244. !     register FILE *fp = NULL;
  1245.   
  1246.       for(i=0; (!fp && (i < _NFILE)); ++i)
  1247.           if(!(_iob[i]._flag & (_IORW | _IOREAD | _IOWRT))) 
  1248. ***************
  1249. *** 99,111 ****
  1250.       }
  1251.       else
  1252.         {
  1253. !         errno = EMFILE;
  1254. !         return NULL;
  1255.         }
  1256.       }
  1257.   
  1258.   /*
  1259. !  * re-coded,  foobared code ifdef'ed below
  1260.    *
  1261.    *    ++jrb
  1262.    */
  1263. --- 94,106 ----
  1264.       }
  1265.       else
  1266.         {
  1267. !         errno = EMFILE;
  1268. !         return NULL;
  1269.         }
  1270.       }
  1271.   
  1272.   /*
  1273. !  * re-coded,  foobared code deleted
  1274.    *
  1275.    *    ++jrb
  1276.    */
  1277. ***************
  1278. *** 124,131 ****
  1279.           if(fflush(fp) != 0) return NULL;            /* flush err */
  1280.           if(close(fp->_file) != 0) return NULL;        /* close err */
  1281.   #else
  1282. !         /* ANSI says ignore errors */
  1283. !         (void)fflush(fp); (void)close(fp->_file);
  1284.   #endif
  1285.       }
  1286.       /* save buffer discipline and setbuf settings, and _IOWRT just for
  1287. --- 119,125 ----
  1288.           if(fflush(fp) != 0) return NULL;            /* flush err */
  1289.           if(close(fp->_file) != 0) return NULL;        /* close err */
  1290.   #else
  1291. !     fflush(fp); close(fp->_file);        /* ANSI says ignore errors */
  1292.   #endif
  1293.       }
  1294.       /* save buffer discipline and setbuf settings, and _IOWRT just for
  1295. *** 1.14    1991/06/20 02:12:19
  1296. --- fprintf.c    1992/06/03 14:49:17
  1297. ***************
  1298. *** 1,58 ****
  1299. - /* from Dale Schumacher's dLibs */
  1300. - 
  1301.   #include <stdio.h>
  1302.   #include <stdarg.h>
  1303. - #include <compiler.h>
  1304.   #include "lib.h"
  1305.   
  1306. ! __EXTERN int _doprnt __PROTO((FILE *file, const char *fmt, va_list argp));
  1307.   
  1308. ! #ifdef __STDC__
  1309.   int fprintf(FILE *fp, const char *fmt, ...)
  1310.   #else
  1311. ! int fprintf(fp, fmt)
  1312. !     FILE *fp;
  1313. !     const char *fmt;
  1314.   #endif
  1315. !     {
  1316. !     va_list argp;
  1317. !     va_start(argp, fmt);
  1318. !     return(_doprnt(fp, fmt, argp));
  1319. !     }
  1320.   
  1321. ! int vfprintf(fp, fmt, args)
  1322.       FILE *fp;
  1323.       const char *fmt;
  1324.       va_list args;
  1325. !     {
  1326.       return(_doprnt(fp, fmt, args));
  1327. !     }
  1328.   
  1329. ! #ifdef __STDC__
  1330.   int printf(const char *fmt, ...)
  1331.   #else
  1332. ! int printf(fmt)
  1333. !     const char *fmt;
  1334.   #endif
  1335. !     {
  1336. !     va_list argp;
  1337. !     va_start(argp, fmt);
  1338. !     return(_doprnt(stdout, fmt, argp));
  1339. !     }
  1340.   
  1341. ! int vprintf(fmt, args)
  1342.       const char *fmt;
  1343.       va_list args;
  1344. -     {
  1345. -     return(_doprnt(stdout, fmt, args));
  1346. -     }
  1347. - 
  1348. - /* This is used by the `assert' macro.  */
  1349. - void __eprintf (string, expression, line, filename)
  1350. - const char *string;
  1351. - const char *expression;
  1352. - const long line;
  1353. - const char *filename; /* note if STDC then filename is already in string */
  1354.   {
  1355. !     (void)fprintf(stderr, string, expression, line, filename);
  1356.   }
  1357. --- 1,53 ----
  1358.   #include <stdio.h>
  1359.   #include <stdarg.h>
  1360.   #include "lib.h"
  1361.   
  1362. ! /* revised 4/15/92 sb -- moved __eprintf to a separate file to avoid conflict
  1363. !    with libm.a's printf */
  1364.   
  1365. ! #if __STDC__
  1366.   int fprintf(FILE *fp, const char *fmt, ...)
  1367.   #else
  1368. ! int fprintf(fp, fmt) FILE *fp; const char *fmt;
  1369.   #endif
  1370. ! {
  1371. !     int r;
  1372. !     va_list args;
  1373. ! 
  1374. !     va_start(args, fmt);
  1375. !     r = _doprnt(fp, fmt, args);
  1376. !     va_end(args);
  1377. !     return r;
  1378. ! }
  1379.   
  1380. ! int
  1381. ! vfprintf(fp, fmt, args)
  1382.       FILE *fp;
  1383.       const char *fmt;
  1384.       va_list args;
  1385. ! {
  1386.       return(_doprnt(fp, fmt, args));
  1387. ! }
  1388.   
  1389. ! #if __STDC__
  1390.   int printf(const char *fmt, ...)
  1391.   #else
  1392. ! int printf(fmt) const char *fmt;
  1393.   #endif
  1394. ! {
  1395. !     va_list args;
  1396. !     int r;
  1397. ! 
  1398. !     va_start(args, fmt);
  1399. !     r = _doprnt(stdout, fmt, args);
  1400. !     va_end(args);
  1401. !     return r;
  1402. ! }
  1403.   
  1404. ! int
  1405. ! vprintf(fmt, args)
  1406.       const char *fmt;
  1407.       va_list args;
  1408.   {
  1409. !     return(_doprnt(stdout, fmt, args));
  1410.   }
  1411. *** 1.11    1992/01/29 20:58:29
  1412. --- fputc.c    1992/06/03 14:49:17
  1413. ***************
  1414. *** 1,7 ****
  1415.   /* from Dale Schumacher's dLibs */
  1416.   
  1417.   #include <stdio.h>
  1418. - #include <unistd.h>
  1419.   #include "lib.h"
  1420.   
  1421.   #ifndef TRUE
  1422. --- 1,6 ----
  1423. ***************
  1424. *** 12,18 ****
  1425.   int fputc(c, fp)
  1426.           register int c;
  1427.       register FILE *fp;
  1428. !     {
  1429.       register int nl = FALSE;
  1430.       register long m;
  1431.       unsigned int f = fp->_flag;
  1432. --- 11,17 ----
  1433.   int fputc(c, fp)
  1434.           register int c;
  1435.       register FILE *fp;
  1436. ! {
  1437.       register int nl = FALSE;
  1438.       register long m;
  1439.       unsigned int f = fp->_flag;
  1440. ***************
  1441. *** 23,54 ****
  1442.           f = (fp->_flag &= ~(_IOREAD | _IOEOF));
  1443.       }
  1444.       if(!(f & _IOWRT)            /* not opened for write? */
  1445. !     || (f & (_IOERR | _IOEOF)))        /* error/eof conditions? */
  1446.           return(EOF);
  1447.   
  1448.       if(!(f & _IOBIN) && (c == '\n'))    /* NL -> CR+LF ? */
  1449. !         {
  1450.           c = '\r';
  1451.           nl = TRUE;
  1452. !         }
  1453.   _fputc:
  1454.       *(fp->_ptr)++ = c; fp->_cnt++;
  1455.       if( (fp->_cnt >= fp->_bsiz) || 
  1456.           ((f & _IOLBF) && (c == '\n'))  ) /* flush line buffd stream on \n */
  1457. !         {
  1458.           m = fp->_cnt;
  1459.           fp->_cnt = 0;
  1460.           fp->_ptr = fp->_base;
  1461. !         if(_write(fp->_file, fp->_base, m) != m)
  1462. !             {
  1463.               fp->_flag |= _IOERR;
  1464.               return(EOF);
  1465. -             }
  1466.           }
  1467. !     if(nl && (c == '\r'))            /* NL -> CR+LF ? */
  1468. !         {
  1469.           c = '\n';
  1470.           goto _fputc;
  1471. -         }
  1472. -     return(c & 0xff);
  1473.       }
  1474. --- 22,51 ----
  1475.           f = (fp->_flag &= ~(_IOREAD | _IOEOF));
  1476.       }
  1477.       if(!(f & _IOWRT)            /* not opened for write? */
  1478. !        || (f & (_IOERR | _IOEOF)))        /* error/eof conditions? */
  1479.           return(EOF);
  1480.   
  1481.       if(!(f & _IOBIN) && (c == '\n'))    /* NL -> CR+LF ? */
  1482. !     {
  1483.           c = '\r';
  1484.           nl = TRUE;
  1485. !     }
  1486.   _fputc:
  1487.       *(fp->_ptr)++ = c; fp->_cnt++;
  1488.       if( (fp->_cnt >= fp->_bsiz) || 
  1489.           ((f & _IOLBF) && (c == '\n'))  ) /* flush line buffd stream on \n */
  1490. !     {
  1491.           m = fp->_cnt;
  1492.           fp->_cnt = 0;
  1493.           fp->_ptr = fp->_base;
  1494. !         if(_write(fp->_file, fp->_base, m) != m) {
  1495.               fp->_flag |= _IOERR;
  1496.               return(EOF);
  1497.           }
  1498. !     }
  1499. !     if(nl && (c == '\r')) {            /* NL -> CR+LF ? */
  1500.           c = '\n';
  1501.           goto _fputc;
  1502.       }
  1503. +     return(c & 0xff);
  1504. + }
  1505. *** 1.6    1992/03/06 19:19:47
  1506. --- ftw.c    1992/06/03 14:49:18
  1507. ***************
  1508. *** 18,28 ****
  1509.   int
  1510.   ftw(directory, funcptr, depth)
  1511.       char         *directory;
  1512. - #if __STDC__
  1513. -     int            (*funcptr)(char *name, struct stat *statp, int flag);
  1514. - #else
  1515.       int            (*funcptr)();
  1516. - #endif
  1517.       int              depth;
  1518.   {
  1519.       register DIR     *dirp;
  1520. --- 18,24 ----
  1521. ***************
  1522. *** 30,39 ****
  1523. --- 26,39 ----
  1524.       struct stat          stats;
  1525.       register char     *p;
  1526.       register int      i;
  1527. + #ifndef __MINT__
  1528.       long          seekpoint;
  1529. + #endif
  1530.       char         *fullpath;
  1531.   
  1532. + #ifndef __MINT__
  1533.       seekpoint = 0;    /* avoid spurious warning from gcc -Wall */
  1534. + #endif
  1535.   
  1536.       /* If can't stat, tell the user so. */
  1537.       if (stat(directory, &stats) < 0)
  1538. ***************
  1539. *** 58,64 ****
  1540.   
  1541.       /* Get ready to hold the full paths. */
  1542.       i = strlen(directory);
  1543. !     fullpath = malloc((size_t)(i + 1 + MAXNAMLEN + 1));
  1544.       if (fullpath == NULL) {
  1545.       closedir(dirp);
  1546.       return -1;
  1547. --- 58,64 ----
  1548.   
  1549.       /* Get ready to hold the full paths. */
  1550.       i = strlen(directory);
  1551. !     fullpath = (char *) malloc( (size_t) (i + 1 + MAXNAMLEN + 1) );
  1552.       if (fullpath == NULL) {
  1553.       closedir(dirp);
  1554.       return -1;
  1555. ***************
  1556. *** 71,76 ****
  1557. --- 71,77 ----
  1558.       /* Read all entries in the directory.. */
  1559.       while (entp = readdir(dirp))
  1560.       if (!EQ(entp->d_name, ".") && !EQ(entp->d_name, "..")) {
  1561. + #ifndef __MINT__
  1562.           if (depth <= 1) {
  1563.           /* Going too deep; checkpoint and close this directory. */
  1564.           seekpoint = telldir(dirp);
  1565. ***************
  1566. *** 77,83 ****
  1567.           closedir(dirp);
  1568.           dirp = NULL;
  1569.           }
  1570. ! 
  1571.           /* Process the file. */
  1572.           (void)strcpy(p, entp->d_name);
  1573.           i = ftw(fullpath, funcptr, depth - 1);
  1574. --- 78,84 ----
  1575.           closedir(dirp);
  1576.           dirp = NULL;
  1577.           }
  1578. ! #endif
  1579.           /* Process the file. */
  1580.           (void)strcpy(p, entp->d_name);
  1581.           i = ftw(fullpath, funcptr, depth - 1);
  1582. ***************
  1583. *** 89,94 ****
  1584. --- 90,96 ----
  1585.           return i;
  1586.           }
  1587.   
  1588. + #ifndef __MINT__
  1589.           /* Reopen the directory if necessary. */
  1590.           if (dirp == NULL) {
  1591.           dirp = opendir(directory);
  1592. ***************
  1593. *** 98,103 ****
  1594. --- 100,106 ----
  1595.           }
  1596.           seekdir(dirp, seekpoint);
  1597.           }
  1598. + #endif
  1599.       }
  1600.   
  1601.       /* Clean up. */
  1602. *** 1.6    1992/03/22 21:57:30
  1603. --- getlogin.c    1992/06/03 14:49:19
  1604. ***************
  1605. *** 3,13 ****
  1606.    */
  1607.   
  1608.   #include <pwd.h>
  1609. - #include <support.h>
  1610. - #include <unistd.h>
  1611.   #include <string.h>
  1612.   #include <stdlib.h>
  1613.   #include <memory.h>
  1614.   
  1615.   static char *logname = NULL;
  1616.   
  1617. --- 3,16 ----
  1618.    */
  1619.   
  1620.   #include <pwd.h>
  1621.   #include <string.h>
  1622.   #include <stdlib.h>
  1623.   #include <memory.h>
  1624. + #include <unistd.h>
  1625. + 
  1626. + #ifdef __GNUC__
  1627. + #define alloca __builtin_alloca
  1628. + #endif
  1629.   
  1630.   static char *logname = NULL;
  1631.   
  1632. *** 1.8    1992/04/19 16:02:45
  1633. --- getopt.c    1992/06/03 14:49:19
  1634. ***************
  1635. *** 14,27 ****
  1636.   #include     <stddef.h>
  1637.   #include    <stdio.h>
  1638.   #include    <string.h>
  1639. - #include     <unistd.h>
  1640.   
  1641.   int    opterr = 1;            /* error => print message */
  1642.   int    optind = 1;            /* next argv[] index */
  1643.   char    *optarg = NULL;            /* option parameter if any */
  1644.   
  1645. - static char mtail[] = " -- x\n";
  1646. - 
  1647.   static int
  1648.   Err( name, mess, c )            /* returns '?' */
  1649.       char    *name;            /* program name argv[0] */
  1650. --- 14,24 ----
  1651. ***************
  1652. *** 29,41 ****
  1653.       int    c;            /* defective option letter */
  1654.       {
  1655.       if ( opterr )
  1656. !         {
  1657. !             mtail[4] = (char)c;
  1658. !             (void) fputs(name, stderr);
  1659. !             (void) fputs(": ", stderr);
  1660. !             (void) fputs(mess, stderr);
  1661. !             (void) fputs(&mtail[0], stderr);
  1662. !         }
  1663.       return '?';            /* erroneous-option marker */
  1664.       }
  1665.   
  1666. --- 26,36 ----
  1667.       int    c;            /* defective option letter */
  1668.       {
  1669.       if ( opterr )
  1670. !         (void) fprintf( stderr,
  1671. !                 "%s: %s -- %c\n",
  1672. !                 name, mess, c
  1673. !                   );
  1674. ! 
  1675.       return '?';            /* erroneous-option marker */
  1676.       }
  1677.   
  1678. ***************
  1679. *** 42,48 ****
  1680.   int
  1681.   getopt( argc, argv, optstring )        /* returns letter, '?', EOF */
  1682.       int        argc;        /* argument count from main */
  1683. !     char *const     *argv;        /* argument vector from main */
  1684.       const char    *optstring;    /* allowed args, e.g. "ab:c" */
  1685.       {
  1686.       static int    sp = 1;        /* position within argument */
  1687. --- 37,43 ----
  1688.   int
  1689.   getopt( argc, argv, optstring )        /* returns letter, '?', EOF */
  1690.       int        argc;        /* argument count from main */
  1691. !         const char      *argv[];        /* argument vector from main */
  1692.       const char    *optstring;    /* allowed args, e.g. "ab:c" */
  1693.       {
  1694.       static int    sp = 1;        /* position within argument */
  1695. *** 1.4    1991/04/12 18:19:53
  1696. --- getpid.c    1992/06/03 14:49:19
  1697. ***************
  1698. *** 1,19 ****
  1699. ! /* from Dale Schumacher's dLibs library */
  1700.   #include <unistd.h>
  1701.   #include <basepage.h>
  1702.   
  1703. ! int getpid()
  1704. !     {
  1705. !     register unsigned long n;
  1706.   
  1707. !     n = (unsigned long) _base;    /* load process base address */
  1708. !     return(0x7FFF & (n >> 8));    /* create unique pid from it */
  1709. !     }
  1710. ! 
  1711. ! int getppid()
  1712. !     {
  1713. !     register unsigned long n;
  1714. ! 
  1715. !     n = (unsigned long) _base->p_parent; /* load parents base address */
  1716. !       return(0x7FFF & (n >> 8));    /* create unique pid from it */
  1717. !       }
  1718. --- 1,9 ----
  1719. ! #include <osbind.h>
  1720.   #include <unistd.h>
  1721.   #include <basepage.h>
  1722. + #include "mintbind.h"
  1723.   
  1724. ! extern int __mint;
  1725.   
  1726. ! int getpid() { return __mint ? Pgetpid() : ( ((long)_base) >> 8 ); }
  1727. ! int getppid() { return __mint ? Pgetppid() : (((long)(_base->p_parent)) >> 8); }
  1728. *** 1.9    1992/01/29 20:58:29
  1729. --- getpw.c    1992/06/03 14:49:20
  1730. ***************
  1731. *** 29,41 ****
  1732.   arnold@emoryu1.{CSNET, UUCP, ARPA, BITNET}
  1733.   */
  1734.   
  1735.   #include <stdio.h>
  1736. - #include <types.h>
  1737.   #include <pwd.h>
  1738.   #include <unistd.h>
  1739. - #include <support.h>
  1740. - #include <stdlib.h>
  1741.   #include <string.h>
  1742.   
  1743.   static char *pwdfile = "/etc/passwd";    /* default passwd file */
  1744.   
  1745. --- 29,41 ----
  1746.   arnold@emoryu1.{CSNET, UUCP, ARPA, BITNET}
  1747.   */
  1748.   
  1749. + /* minorly customized by ERS for the MiNT library */
  1750. + 
  1751.   #include <stdio.h>
  1752.   #include <pwd.h>
  1753.   #include <unistd.h>
  1754.   #include <string.h>
  1755. + #include <stdlib.h>
  1756.   
  1757.   static char *pwdfile = "/etc/passwd";    /* default passwd file */
  1758.   
  1759. ***************
  1760. *** 42,48 ****
  1761.   static FILE *fp = NULL;
  1762.   static struct passwd curentry;        /* static data to return */
  1763.   
  1764. ! static int nextent(void);
  1765.   
  1766.   void setpwfile (cp)
  1767.   char *cp;
  1768. --- 42,48 ----
  1769.   static FILE *fp = NULL;
  1770.   static struct passwd curentry;        /* static data to return */
  1771.   
  1772. ! static int nextent __PROTO((void));
  1773.   
  1774.   void setpwfile (cp)
  1775.   char *cp;
  1776. ***************
  1777. *** 51,57 ****
  1778.       if(cp) pwdfile = cp;
  1779.   }
  1780.   
  1781. ! int setpwent ()
  1782.   {
  1783.       if (fp)
  1784.           rewind (fp);
  1785. --- 51,57 ----
  1786.       if(cp) pwdfile = cp;
  1787.   }
  1788.   
  1789. ! void setpwent ()
  1790.   {
  1791.       if (fp)
  1792.           rewind (fp);
  1793. ***************
  1794. *** 65,76 ****
  1795.           fprintf (stderr,
  1796.               "setpwent: %s non-existant or unreadable.\n", pwdfile);
  1797.   #endif
  1798. -         return (0);
  1799.       }
  1800. -     return (1);
  1801.   }
  1802.   
  1803. ! int endpwent ()
  1804.   {
  1805.       if (fp)
  1806.       {
  1807. --- 65,74 ----
  1808.           fprintf (stderr,
  1809.               "setpwent: %s non-existant or unreadable.\n", pwdfile);
  1810.   #endif
  1811.       }
  1812.   }
  1813.   
  1814. ! void endpwent ()
  1815.   {
  1816.       if (fp)
  1817.       {
  1818. ***************
  1819. *** 77,89 ****
  1820.           fclose (fp);
  1821.           fp = NULL;
  1822.       }
  1823. -     return 1;
  1824.   }
  1825.   
  1826.   struct passwd *getpwent ()
  1827.   {
  1828. !     if (! fp && ! setpwent ())
  1829. !         return (NULL);
  1830.   
  1831.       if (! nextent ())
  1832.           return (NULL);
  1833. --- 75,89 ----
  1834.           fclose (fp);
  1835.           fp = NULL;
  1836.       }
  1837.   }
  1838.   
  1839.   struct passwd *getpwent ()
  1840.   {
  1841. !     if (! fp ) {
  1842. !         setpwent();
  1843. !         if (! fp )
  1844. !             return (NULL);
  1845. !     }
  1846.   
  1847.       if (! nextent ())
  1848.           return (NULL);
  1849. ***************
  1850. *** 91,106 ****
  1851.           return (& curentry);
  1852.   }
  1853.   
  1854. - #if __STDC__
  1855. - struct passwd *getpwuid (uid_t uid)
  1856. - #else
  1857.   struct passwd *getpwuid (uid)
  1858. ! uid_t uid;
  1859. ! #endif
  1860.   {
  1861. !     if (! setpwent ())
  1862. !         return (NULL);
  1863. ! 
  1864.       while (nextent ())
  1865.           if (curentry.pw_uid == uid)
  1866.               return (& curentry);
  1867. --- 91,100 ----
  1868.           return (& curentry);
  1869.   }
  1870.   
  1871.   struct passwd *getpwuid (uid)
  1872. ! register int uid;
  1873.   {
  1874. !     setpwent ();
  1875.       while (nextent ())
  1876.           if (curentry.pw_uid == uid)
  1877.               return (& curentry);
  1878. ***************
  1879. *** 111,118 ****
  1880.   struct passwd *getpwnam (name)
  1881.   register const char *name;
  1882.   {
  1883. !     if (! setpwent ())
  1884. !         return (NULL);
  1885.   
  1886.       while (nextent ())
  1887.           if (strcmp (curentry.pw_name, name) == 0)
  1888. --- 105,111 ----
  1889.   struct passwd *getpwnam (name)
  1890.   register const char *name;
  1891.   {
  1892. !     setpwent ();
  1893.   
  1894.       while (nextent ())
  1895.           if (strcmp (curentry.pw_name, name) == 0)
  1896. ***************
  1897. *** 121,134 ****
  1898.       return (NULL);
  1899.   }
  1900.   
  1901.   static char savbuf[BUFSIZ];
  1902.           
  1903.   static int nextent ()
  1904.   {
  1905.       register char *cp;
  1906.   
  1907. !     if (! fp && ! setpwent ())
  1908. !         return (0);
  1909.   
  1910.       while (fgets (savbuf, sizeof(savbuf), fp) != NULL)
  1911.       {
  1912. --- 114,134 ----
  1913.       return (NULL);
  1914.   }
  1915.   
  1916. + #ifdef atarist
  1917. + static char savbuf[256];    /* BUFSIZ seems bigger than necessary! */
  1918. + #else
  1919.   static char savbuf[BUFSIZ];
  1920. + #endif
  1921.           
  1922.   static int nextent ()
  1923.   {
  1924.       register char *cp;
  1925.   
  1926. !     if (! fp ) {
  1927. !         setpwent ();
  1928. !         if (! fp )
  1929. !             return (0);
  1930. !     }
  1931.   
  1932.       while (fgets (savbuf, sizeof(savbuf), fp) != NULL)
  1933.       {
  1934. *** 1.6    1992/04/13 15:50:45
  1935. --- getuid.c    1992/06/03 14:49:20
  1936. ***************
  1937. *** 1,26 ****
  1938. ! /* fake UNIX getuid, setuid, etc. calls.
  1939. !    In fact, all we can do is pretend.
  1940. !    By ERS
  1941. ! */
  1942. ! 
  1943.   #include <unistd.h>
  1944. ! 
  1945. ! /* pretending we are root (0,0) is probably not a good idea */
  1946. ! static uid_t euid = 1, uid = 1;
  1947. ! static gid_t egid = 1, gid = 1;
  1948. !   
  1949. ! uid_t getuid() { return uid; }
  1950. ! uid_t geteuid(){ return euid; }
  1951. ! 
  1952. ! gid_t getgid() { return gid; }
  1953. ! gid_t getegid() { return egid; }
  1954. ! 
  1955. ! uid_t setuid(x) int x; { return uid = x; }
  1956. ! gid_t setgid(x) int x; { return gid = x; }
  1957. ! 
  1958. ! uid_t seteuid(x) int x; { return euid = x; }
  1959. ! gid_t setegid(x) int x; { return egid = x; }
  1960. !   
  1961. ! int setpgrp() { return getpid(); }
  1962. ! int getpgrp() { return getpid(); }
  1963.   
  1964. --- 1,73 ----
  1965. ! #include <sys/types.h>
  1966.   #include <unistd.h>
  1967. ! #include <osbind.h>
  1968. ! #include <mintbind.h>
  1969. ! #include <errno.h>
  1970. ! 
  1971. ! extern int __mint;
  1972. ! 
  1973. ! static int __uid = 1, __gid = 1;
  1974. ! 
  1975. ! uid_t getuid() { return __mint ? Pgetuid() : __uid; }
  1976. ! gid_t getgid() { return __mint ? Pgetgid() : __gid; }
  1977. ! 
  1978. ! uid_t geteuid() { return getuid(); }
  1979. ! gid_t getegid() { return getgid(); }
  1980. ! 
  1981. ! int setuid(x)
  1982. !     int x;
  1983. ! {
  1984. !     long r;
  1985. ! 
  1986. !     if (__mint) {
  1987. !         r = Psetuid(x);
  1988. !         if (r) {
  1989. !             errno = -r;
  1990. !             return -1;
  1991. !         }
  1992. !         return 0;
  1993. !     }
  1994. !     __uid = x;
  1995. !     return 0;
  1996. ! }
  1997. ! 
  1998. ! int setgid(x)
  1999. !     int x;
  2000. ! {
  2001. !     long r;
  2002. ! 
  2003. !     if (__mint) {
  2004. !         r = Psetgid(x);
  2005. !         if (r) {
  2006. !             errno = -r;
  2007. !             return -1;
  2008. !         }
  2009. !         return 0;
  2010. !     }
  2011. !     __gid = x;
  2012. !     return 0;
  2013. ! }
  2014. ! 
  2015. ! int setreuid(ruid,euid)
  2016. !     int ruid, euid;
  2017. ! {
  2018. !     return setuid(euid);
  2019. ! }
  2020. ! 
  2021. ! int setregid(rgid,egid)
  2022. !     int rgid, egid;
  2023. ! {
  2024. !     return setgid(egid);
  2025. ! }
  2026. ! 
  2027. ! /* note: BSD getpgrp takes an argument, but ours doesn't */
  2028. ! int getpgrp() { return __mint ? Pgetpgrp() : 0; }
  2029. ! 
  2030. ! int setpgrp(pid, grp)
  2031. !     int pid, grp;
  2032. ! {
  2033. !     return __mint ? Psetpgrp(pid, grp) : 0;
  2034. ! }
  2035.   
  2036. + int seteuid(x) int x; { return setuid(x); }
  2037. + int setegid(x) int x; { return setgid(x); }
  2038. *** 1.8    1992/04/06 19:33:32
  2039. --- gmon.c    1992/06/03 14:49:20
  2040. ***************
  2041. *** 16,21 ****
  2042. --- 16,22 ----
  2043.   #include <basepage.h>
  2044.   #include <sysvars.h>
  2045.   #include <xbra.h>
  2046. + #include <string.h>
  2047.   #ifndef _COMPILER_H
  2048.   #include <compiler.h>
  2049.   #endif
  2050. ***************
  2051. *** 617,623 ****
  2052.       ((unsigned long)Setexc(exc, -1L) - offsetof(xbra_struct, jump));
  2053.       if(this == me)
  2054.       {    /* at the head, just unlink */
  2055. !     Setexc(exc, me->next);
  2056.       return;
  2057.       }
  2058.       /* otherwise find me in the chain and unlink */
  2059. --- 618,624 ----
  2060.       ((unsigned long)Setexc(exc, -1L) - offsetof(xbra_struct, jump));
  2061.       if(this == me)
  2062.       {    /* at the head, just unlink */
  2063. !     (void)Setexc(exc, me->next);
  2064.       return;
  2065.       }
  2066.       /* otherwise find me in the chain and unlink */
  2067. ***************
  2068. *** 630,636 ****
  2069.       if(this->xbra_magic != _XBRA_MAGIC) 
  2070.       {    /* shame on you */
  2071.           Super(save_ssp);
  2072. !         Setexc(exc, me->next); /* nuke it, otherwise it may call ME */
  2073.           return;           /* after i am deinstalled */
  2074.       }
  2075.       }
  2076. --- 631,637 ----
  2077.       if(this->xbra_magic != _XBRA_MAGIC) 
  2078.       {    /* shame on you */
  2079.           Super(save_ssp);
  2080. !         (void)Setexc(exc, me->next); /* nuke it, otherwise it may call ME */
  2081.           return;           /* after i am deinstalled */
  2082.       }
  2083.       }
  2084. *** 1.4    1991/04/26 03:42:08
  2085. --- grp.c    1992/06/03 14:49:21
  2086. ***************
  2087. *** 1,47 ****
  2088.   /*
  2089. !  * faking of group id's. written by ERS; it's public domain, if
  2090. !  * you want it!
  2091.    */
  2092.   
  2093.   #include <string.h>
  2094.   #include <stdlib.h>
  2095.   #include <unistd.h>
  2096.   #include <grp.h>
  2097.   
  2098. ! __EXTERN char *    getlogin    __PROTO((void));
  2099.   
  2100. ! static char root_str[] = "root";
  2101. ! static char user_str[80];
  2102.   
  2103. ! static char *root_mem[] = { root_str, (char *)0 };
  2104. ! static char *user_mem[] = { root_str, user_str, (char *)0 };
  2105.   
  2106. ! static struct group root_group = { root_str, "", 0, root_mem };
  2107. ! static struct group user_group = { "user", "", 1, user_mem };
  2108.   
  2109. ! struct group *
  2110. ! getgrgid(gid)
  2111. !     int gid;
  2112.   {
  2113. !     if (gid == 0)
  2114. !         return &root_group;
  2115. !     else if (gid == 1) {
  2116. !         strcpy(user_str, getlogin());
  2117. !         return &user_group;
  2118.       }
  2119. -     else
  2120. -         return 0;
  2121.   }
  2122.   
  2123. ! struct group *
  2124. ! getgrnam(name)
  2125. !     char *name;
  2126. ! {
  2127. !     strcpy(user_str, getlogin());
  2128. !     if (!strcmp(name, root_str))
  2129. !         return &root_group;
  2130. !     else if (!strcmp(name, "user"))
  2131. !         return &user_group;
  2132.       else
  2133. !         return 0;
  2134.   }
  2135. --- 1,174 ----
  2136.   /*
  2137. !  * Routines for reading information from /etc/group.
  2138. !  * Written by Eric Smith, based on Arnold Robbins' public domain
  2139. !  * getpwent routines (see getpw.c).
  2140.    */
  2141.   
  2142. + #include <stdio.h>
  2143.   #include <string.h>
  2144.   #include <stdlib.h>
  2145.   #include <unistd.h>
  2146.   #include <grp.h>
  2147.   
  2148. ! static char *grpfile = "/etc/group";    /* default group file */
  2149. ! static FILE *fp;
  2150.   
  2151. ! static struct group curentry;        /* static data to return */
  2152.   
  2153. ! static int nextent __PROTO((void));
  2154.   
  2155. ! void setgrent ()
  2156. ! {
  2157. !     if (fp)
  2158. !         rewind (fp);
  2159. ! #ifdef atarist
  2160. !     else if ((fp = fopen (grpfile, "rt")) == NULL)
  2161. ! #else
  2162. !     else if ((fp = fopen (grpfile, "r")) == NULL)
  2163. ! #endif
  2164. !     {
  2165. ! #ifdef VERBOSE
  2166. !         fprintf (stderr,
  2167. !             "setgrent: %s non-existant or unreadable.\n", grpfile);
  2168. ! #endif
  2169. !     }
  2170. ! }
  2171.   
  2172. ! void endgrent ()
  2173.   {
  2174. !     if (fp)
  2175. !     {
  2176. !         fclose (fp);
  2177. !         fp = NULL;
  2178.       }
  2179.   }
  2180.   
  2181. ! struct group *getgrent ()
  2182. ! {
  2183. !     if (!fp) setgrent();
  2184. !     if (!fp) return NULL;
  2185. ! 
  2186. !     if (! nextent ())
  2187. !         return (NULL);
  2188.       else
  2189. !         return (& curentry);
  2190. ! }
  2191. ! 
  2192. ! struct group *getgrgid (gid)
  2193. !     int gid;
  2194. ! {
  2195. !     setgrent();
  2196. ! 
  2197. !     while (nextent ())
  2198. !         if (curentry.gr_gid == gid)
  2199. !             return (& curentry);
  2200. ! 
  2201. !     return (NULL);
  2202. ! }
  2203. ! 
  2204. ! struct group *getgrnam (name)
  2205. ! register char *name;
  2206. ! {
  2207. !     setgrent();
  2208. ! 
  2209. !     while (nextent ())
  2210. !         if (strcmp (curentry.gr_name, name) == 0)
  2211. !             return (& curentry);
  2212. ! 
  2213. !     return (NULL);
  2214. ! }
  2215. ! 
  2216. ! #define MAX_MEMBERS 128        /* max. number of members in a group */
  2217. ! 
  2218. ! static char savbuf[512];
  2219. ! static char *memb[MAX_MEMBERS];
  2220. ! 
  2221. ! static int nextent ()
  2222. ! {
  2223. !     register char *cp;
  2224. !     register int i;
  2225. ! 
  2226. !     if (!fp) setgrent();
  2227. !     if (!fp) return 0;
  2228. ! 
  2229. !     if (fgets (savbuf, sizeof(savbuf), fp) != NULL)
  2230. !     {
  2231. !         for (cp = savbuf; *cp && *cp != ':'; cp++)
  2232. !             ;
  2233. !         curentry.gr_name = savbuf;
  2234. !         *cp++ = '\0';
  2235. !         curentry.gr_passwd = cp;
  2236. !         for (; *cp && *cp != ':'; cp++)
  2237. !             ;
  2238. !         *cp++ = '\0';
  2239. !         curentry.gr_gid = atoi (cp);
  2240. !         for (; *cp && *cp != ':'; cp++)
  2241. !             ;
  2242. ! 
  2243. !         *cp++ = '\0';
  2244. ! 
  2245. !         i = 0;
  2246. !         while( *cp ) {
  2247. !             if (i >= MAX_MEMBERS-1) break;
  2248. !             memb[i++] = cp;
  2249. !             for(; *cp && *cp != ',' && *cp != '\n'; cp++)
  2250. !                 ;
  2251. !             if (*cp == '\n')
  2252. !                 *cp = 0;
  2253. !             else if (*cp)
  2254. !                 *cp++ = 0;
  2255. !         }
  2256. !         memb[i] = NULL;
  2257. !         curentry.gr_mem = memb;
  2258. !         return (1);
  2259. !     }
  2260. !     return (0);
  2261. ! }
  2262. ! 
  2263. ! #ifdef TEST
  2264. ! int
  2265. ! main (argc, argv)
  2266. ! int argc;
  2267. ! char **argv;
  2268. ! {
  2269. !     struct group *gr;
  2270. !     char **m;
  2271. ! 
  2272. !     if (argc > 1) {
  2273. !         grpfile = argv[1];
  2274. !     }
  2275. ! 
  2276. !     setgrent ();
  2277. !     while ((gr = getgrent ()) != NULL)
  2278. !     {
  2279. !         printf ("%s:[%s] %d\n",
  2280. !             gr->gr_name,
  2281. !             gr->gr_passwd,
  2282. !             gr->gr_gid);
  2283. !         for (m = gr->gr_mem; *m; m++) {
  2284. !             printf("\t%s\n", *m);
  2285. !         }
  2286. !     }
  2287. !     endgrent ();
  2288. ! 
  2289. !     if (gr = getgrnam ("mail")) {
  2290. !         printf ("%s:[%s] %d\n",
  2291. !             gr->gr_name,
  2292. !             gr->gr_passwd,
  2293. !             gr->gr_gid);
  2294. !         for (m = gr->gr_mem; *m; m++) {
  2295. !             printf("\t%s\n", *m);
  2296. !         }
  2297. !     }
  2298. !     if (gr = getgrgid (1)) {
  2299. !         printf ("%s:[%s] %d\n",
  2300. !             gr->gr_name,
  2301. !             gr->gr_passwd,
  2302. !             gr->gr_gid);
  2303. !         for (m = gr->gr_mem; *m; m++) {
  2304. !             printf("\t%s\n", *m);
  2305. !         }
  2306. !     }
  2307. !     return 0;
  2308.   }
  2309. + #endif
  2310. *** 1.5    1991/12/26 15:53:59
  2311. --- lib.h    1992/06/03 14:49:22
  2312. ***************
  2313. *** 8,13 ****
  2314. --- 8,14 ----
  2315.   #include <compiler.h>
  2316.   #endif
  2317.   
  2318. + #include <stdio.h>    /* for FILE   */
  2319.   #include <time.h>    /* for time_t */
  2320.   
  2321.   /* filename mapping function type */
  2322. ***************
  2323. *** 14,46 ****
  2324.   #ifndef __FNMAP
  2325.   #define __FNMAP
  2326.   #ifdef __STDC__
  2327. ! typedef void (*fnmapfunc_t)(const char *, char *);
  2328.   #else
  2329. ! typedef void (*fnmapfunc_t)();
  2330.   #endif
  2331.   #endif
  2332.   
  2333. ! int    _unx2dos __PROTO((const char *, char *));
  2334. ! int    _dos2unx __PROTO((const char *, char *));
  2335. ! int    unx2dos __PROTO((const char *, char *));
  2336. ! int    dos2unx __PROTO((const char *, char *));
  2337. ! int    spawnve __PROTO((int, char *, char **, char **));
  2338. ! int    console_input_status __PROTO((int));
  2339. ! unsigned int    console_read_byte __PROTO((int));
  2340. ! void        console_write_byte __PROTO((int, int));
  2341. ! int        dos2unx __PROTO((const char *, char *));
  2342. ! time_t        dostime __PROTO((time_t));
  2343. ! char *        findfile __PROTO((char *, char *, char **));
  2344. ! char *        _itoa __PROTO((int, char *, int));
  2345. ! char *        _ltoa __PROTO((long, char *, int));
  2346. ! char *        _ultoa __PROTO((unsigned long, char *, int));
  2347. ! time_t        unixtime __PROTO((unsigned int, unsigned int));
  2348. ! int        unx2dos __PROTO((const char *, char *));
  2349. ! void        fnmapfunc __PROTO((fnmapfunc_t u2dos, fnmapfunc_t dos2u));
  2350. ! long        get_sysvar __PROTO((void *var));
  2351. ! void        set_sysvar_to_long __PROTO((void *var, long val));
  2352.   
  2353. ! __EXTERN __EXITING __exit __PROTO((long status));
  2354. ! __EXTERN char *_itoa __PROTO((int, char *, int));
  2355.   
  2356.   #endif /* _LIB_H */
  2357. --- 15,71 ----
  2358.   #ifndef __FNMAP
  2359.   #define __FNMAP
  2360.   #ifdef __STDC__
  2361. ! typedef int (*fnmapfunc_t)(const char *, char *);
  2362.   #else
  2363. ! typedef int (*fnmapfunc_t)();
  2364.   #endif
  2365.   #endif
  2366.   
  2367. ! __EXTERN int        _unx2dos __PROTO((const char *, char *));
  2368. ! __EXTERN int        _dos2unx __PROTO((const char *, char *));
  2369. ! __EXTERN int        unx2dos __PROTO((const char *, char *));
  2370. ! __EXTERN int        dos2unx __PROTO((const char *, char *));
  2371. ! __EXTERN void        fnmapfunc __PROTO((fnmapfunc_t u2dos, fnmapfunc_t dos2u));
  2372.   
  2373. ! __EXTERN int        spawnve __PROTO((int, char *, char **, char **));
  2374. ! 
  2375. ! __EXTERN long        _write      __PROTO((int, const void *, unsigned long));
  2376. ! __EXTERN long        _read      __PROTO((int, void *, unsigned long));
  2377. ! __EXTERN int        console_input_status __PROTO((int));
  2378. ! __EXTERN unsigned int    console_read_byte __PROTO((int));
  2379. ! __EXTERN void        console_write_byte __PROTO((int, int));
  2380. ! 
  2381. ! __EXTERN time_t        dostime __PROTO((time_t));
  2382. ! __EXTERN time_t        _unixtime __PROTO((unsigned int, unsigned int));
  2383. ! 
  2384. ! __EXTERN char *        findfile __PROTO((char *, char *, char **));
  2385. ! 
  2386. ! __EXTERN char *        _itoa __PROTO((int, char *, int));
  2387. ! __EXTERN char *        _ltoa __PROTO((long, char *, int));
  2388. ! __EXTERN char *        _ultoa __PROTO((unsigned long, char *, int));
  2389. ! 
  2390. ! __EXTERN int        _doprnt __PROTO((FILE *, const char *, __VA_LIST__));
  2391. ! 
  2392. ! __EXTERN long        get_sysvar __PROTO((void *var));
  2393. ! __EXTERN void        set_sysvar_to_long __PROTO((void *var, long val));
  2394. ! 
  2395. ! __EXTERN __EXITING     __exit __PROTO((long status));
  2396. ! 
  2397. ! /* from the TOS GCC library */
  2398. ! /* 5/5/92 sb -- definitions needed in malloc.c and realloc.c */
  2399. ! 
  2400. ! struct mem_chunk 
  2401. !     {
  2402. !     long valid;
  2403. ! #define VAL_FREE  0xf4ee0abc
  2404. ! #define VAL_ALLOC 0xa11c0abc
  2405. ! 
  2406. !     struct mem_chunk *next;
  2407. !     unsigned long size;
  2408. !     };
  2409. ! 
  2410. ! /* linked list of free blocks */
  2411. ! 
  2412. ! __EXTERN struct mem_chunk _mchunk_free_list;
  2413.   
  2414.   #endif /* _LIB_H */
  2415. *** 1.13    1992/01/29 20:58:29
  2416. --- localtim.c    1992/06/03 14:49:22
  2417. ***************
  2418. *** 39,45 ****
  2419.   mth_start[13] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
  2420.   
  2421.   static time_t tzoffset __PROTO((char *s, int *hasdst));
  2422. ! static int indst __PROTO((const struct tm *t));
  2423.   
  2424.   static int dst = -1;    /* whether dst holds in current timezone */
  2425.   
  2426. --- 39,45 ----
  2427.   mth_start[13] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
  2428.   
  2429.   static time_t tzoffset __PROTO((char *s, int *hasdst));
  2430. ! static int indst __PROTO((long secs, const struct tm *t));
  2431.   
  2432.   static int dst = -1;    /* whether dst holds in current timezone */
  2433.   
  2434. ***************
  2435. *** 54,61 ****
  2436.    *  returned by localtime() and convert it into the standard representation
  2437.    *  (as seconds since midnight Jan. 1 1970, GMT).
  2438.    *
  2439. !  * Note that time() sends us such a structure with tm_yday undefined, so
  2440. !  * we shouldn't count on tm_yday being correct.
  2441.    */
  2442.   
  2443.   time_t
  2444. --- 54,61 ----
  2445.    *  returned by localtime() and convert it into the standard representation
  2446.    *  (as seconds since midnight Jan. 1 1970, GMT).
  2447.    *
  2448. !  * Note that time() sends us such a structure with tm_yday and tm_wday
  2449. !  * undefined, so we shouldn't count on these being correct!
  2450.    */
  2451.   
  2452.   time_t
  2453. ***************
  2454. *** 82,89 ****
  2455.       tzset();
  2456.   
  2457.           s += _timezone;
  2458. !         if (dst == 1 && indst(t))
  2459. !                 s -= 3600;
  2460.   
  2461.           return s;
  2462.   }
  2463. --- 82,89 ----
  2464.       tzset();
  2465.   
  2466.           s += _timezone;
  2467. !         if (dst == 1 && indst(s, t))
  2468. !                 s -= SECS_PER_HOUR;
  2469.   
  2470.           return s;
  2471.   }
  2472. ***************
  2473. *** 148,163 ****
  2474.   {
  2475.       static struct tm ltim;
  2476.           struct tm *stm;
  2477. !         time_t offset;  /* seconds between local time and GMT */
  2478.   
  2479.       tzset();
  2480. !         offset = *t - _timezone;
  2481. !     if(offset < 0) offset = 0; /* this is questionable */
  2482. !         stm = _gmtime(&offset, <im);
  2483.       if (stm == NULL) return stm;        /* check for illegal time */
  2484.           stm->tm_isdst = (dst == -1) ? -1 : 0;
  2485.   
  2486. !         if (dst == 1 && indst((const struct tm *)stm)) {   /* daylight savings time in effect */
  2487.                   stm->tm_isdst = 1;
  2488.                   if (++stm->tm_hour > 23) {
  2489.                           stm->tm_hour -= 24;
  2490. --- 148,163 ----
  2491.   {
  2492.       static struct tm ltim;
  2493.           struct tm *stm;
  2494. !         time_t gmsecs;  /*time in GMT */ 
  2495.   
  2496.       tzset();
  2497. !         gmsecs = *t - _timezone;
  2498. !         stm = _gmtime(&gmsecs, <im);
  2499.       if (stm == NULL) return stm;        /* check for illegal time */
  2500.           stm->tm_isdst = (dst == -1) ? -1 : 0;
  2501.   
  2502. !         if (dst == 1 && indst(*t, (const struct tm *)stm)) {
  2503. !        /* daylight savings time in effect */
  2504.                   stm->tm_isdst = 1;
  2505.                   if (++stm->tm_hour > 23) {
  2506.                           stm->tm_hour -= 24;
  2507. ***************
  2508. *** 170,176 ****
  2509.                           }
  2510.                   }
  2511.           }
  2512. ! DEBUG_TM("localtime", stm);
  2513.           return stm;
  2514.   }
  2515.   
  2516. --- 170,176 ----
  2517.                           }
  2518.                   }
  2519.           }
  2520. !     DEBUG_TM("localtime", stm);
  2521.           return stm;
  2522.   }
  2523.   
  2524. ***************
  2525. *** 302,310 ****
  2526.    */
  2527.   
  2528.   static
  2529. ! int indst(t)
  2530.           const struct tm *t;
  2531.   {
  2532.           if (t->tm_mon == 3) {           /* April */
  2533.   /* before 1987, see if there's another sunday in the month */
  2534.                   if (t->tm_year < 87 && t->tm_wday + 30 - t->tm_mday < 7)
  2535. --- 302,318 ----
  2536.    */
  2537.   
  2538.   static
  2539. ! int indst(s, t)
  2540. !     long s;
  2541.           const struct tm *t;
  2542.   {
  2543. +     int wkday;
  2544. + 
  2545. +     if (t->tm_wday >= 0)
  2546. +         wkday = t->tm_wday;
  2547. +     else
  2548. +         wkday = ((s / SECS_PER_DAY) + 4) % 7;
  2549. + 
  2550.           if (t->tm_mon == 3) {           /* April */
  2551.   /* before 1987, see if there's another sunday in the month */
  2552.                   if (t->tm_year < 87 && t->tm_wday + 30 - t->tm_mday < 7)
  2553. *** 1.7    1992/03/22 21:57:30
  2554. --- lseek.c    1992/06/03 14:49:22
  2555. ***************
  2556. *** 2,17 ****
  2557.   #include <stdio.h>
  2558.   #include <errno.h>
  2559.   #include <osbind.h>
  2560. - #include <unistd.h>
  2561.   #include <memory.h>
  2562.   #include <string.h>
  2563.   #include "lib.h"
  2564. - #ifndef _COMPILER_H
  2565. - #include <compiler.h>
  2566. - #endif
  2567.   
  2568. ! static long _real_lseek __PROTO((int h, long where, int how));
  2569. ! 
  2570.   
  2571.   static long _real_lseek(h, where, how)
  2572.   int h;
  2573. --- 2,17 ----
  2574.   #include <stdio.h>
  2575.   #include <errno.h>
  2576.   #include <osbind.h>
  2577.   #include <memory.h>
  2578.   #include <string.h>
  2579. + #include <unistd.h>
  2580.   #include "lib.h"
  2581.   
  2582. ! #ifdef __GNUC__
  2583. ! #  ifndef alloca
  2584. ! #    define alloca __builtin_alloca
  2585. ! #  endif
  2586. ! #endif
  2587.   
  2588.   static long _real_lseek(h, where, how)
  2589.   int h;
  2590. ***************
  2591. *** 67,73 ****
  2592.           offset = 256;
  2593.       if((current_pos = _write(handle, buf, offset)) != offset)
  2594.           return((current_pos > 0) ? (new_pos + current_pos) :
  2595. !            new_pos);    /* errno set by _write */
  2596.       new_pos += offset;
  2597.       }
  2598.       return(new_pos);  
  2599. --- 67,73 ----
  2600.           offset = 256;
  2601.       if((current_pos = _write(handle, buf, offset)) != offset)
  2602.           return((current_pos > 0) ? (new_pos + current_pos) :
  2603. !            new_pos);    /* errno set by write */
  2604.       new_pos += offset;
  2605.       }
  2606.       return(new_pos);  
  2607. *** 1.6    1991/04/26 03:42:08
  2608. --- ltoa.c    1992/06/03 14:49:23
  2609. ***************
  2610. *** 1,4 ****
  2611. --- 1,5 ----
  2612.   #include <string.h>
  2613. + #include "lib.h"
  2614.   
  2615.   #ifdef __STRICT_ANSI__
  2616.   #  ifdef __GNUC__
  2617. *** 1.20    1992/03/06 19:19:47
  2618. --- malloc.c    1992/06/03 14:49:23
  2619. ***************
  2620. *** 2,13 ****
  2621. --- 2,17 ----
  2622.   /* malloc, free, realloc: dynamic memory allocation */
  2623.   /* ERS: added mlalloc, relalloc, etc. for 16 bit compilers. Changed
  2624.      argument of malloc, etc.,  to size_t (per ANSI draft). */
  2625. + /* 5/2/92 sb -- modified for Heat-n-Serve C to accomodate its 16-bit size_t */
  2626. + /* 5/5/92 sb -- split off realloc() & calloc() to reduce library drag */
  2627.   
  2628.   #include <stddef.h>    /* for size_t */
  2629. + #include <stdlib.h>
  2630.   #include <memory.h>
  2631.   #include <string.h>
  2632.   #include <assert.h>
  2633.   #include <unistd.h>
  2634. + #include "lib.h"
  2635.   
  2636.   extern long _stksize;
  2637.   
  2638. ***************
  2639. *** 20,47 ****
  2640.               gets screwed on a 1M machine otherwise (stack/heap clash)
  2641.        */
  2642.   
  2643. ! struct mem_chunk 
  2644. !     {
  2645. !     long valid;
  2646. ! #define VAL_FREE  0xf4ee0abc
  2647. ! #define VAL_ALLOC 0xa11c0abc
  2648. ! 
  2649. !     struct mem_chunk *next;
  2650. !     long size;
  2651. !     };
  2652.   
  2653. ! /* linked list of free blocks */
  2654.   
  2655. - static struct mem_chunk _mchunk_free_list = { VAL_FREE, NULL, 0L };
  2656. - 
  2657.   /* flag to control zero'ing of malloc'ed chunks */
  2658.   static int _ZeroMallocs = 0;
  2659.   
  2660.   
  2661. ! asm(".stabs \"_mlalloc\",5,0,0,_malloc"); /* dept of clean tricks */
  2662.   
  2663. ! void * malloc(n)
  2664. ! size_t n; 
  2665.   {
  2666.     struct mem_chunk *p, *q;
  2667.     long sz;
  2668. --- 24,45 ----
  2669.               gets screwed on a 1M machine otherwise (stack/heap clash)
  2670.        */
  2671.   
  2672. ! /* linked list of free blocks struct defined in lib.h */
  2673.   
  2674. ! struct mem_chunk _mchunk_free_list = { VAL_FREE, NULL, 0L };
  2675.   
  2676.   /* flag to control zero'ing of malloc'ed chunks */
  2677.   static int _ZeroMallocs = 0;
  2678.   
  2679. + __EXTERN void _bzero __PROTO((void *, unsigned long));
  2680. + __EXTERN void *_sbrk __PROTO((long));
  2681.   
  2682. ! #ifdef __GNUC__
  2683. ! asm(".stabs \"_malloc\",5,0,0,__malloc"); /* dept of clean tricks */
  2684. ! #endif
  2685.   
  2686. ! void * _malloc(n)
  2687. ! unsigned long n; 
  2688.   {
  2689.     struct mem_chunk *p, *q;
  2690.     long sz;
  2691. ***************
  2692. *** 71,77 ****
  2693.           if (MINHUNK < MAXHUNK)
  2694.               MINHUNK *= 2;
  2695.       }
  2696. !     q = (struct mem_chunk * )sbrk(sz);
  2697.   
  2698.       if (((long)q) == -1)         /* can't alloc any more? */
  2699.           return(NULL);
  2700. --- 69,75 ----
  2701.           if (MINHUNK < MAXHUNK)
  2702.               MINHUNK *= 2;
  2703.       }
  2704. !     q = (struct mem_chunk * )_sbrk(sz);
  2705.   
  2706.       if (((long)q) == -1)         /* can't alloc any more? */
  2707.           return(NULL);
  2708. ***************
  2709. *** 102,108 ****
  2710.     q->next = NULL;    
  2711.     q++;    /* hand back ptr to after chunk desc */
  2712.     if(_ZeroMallocs != 0)
  2713. !       bzero((void *)q, (long)(n - sizeof(struct mem_chunk)));
  2714.     
  2715.     return((void * )q);
  2716.   }
  2717. --- 100,106 ----
  2718.     q->next = NULL;    
  2719.     q++;    /* hand back ptr to after chunk desc */
  2720.     if(_ZeroMallocs != 0)
  2721. !       _bzero((void *)q, (long)(n - sizeof(struct mem_chunk)));
  2722.     
  2723.     return((void * )q);
  2724.   }
  2725. ***************
  2726. *** 184,272 ****
  2727.       }
  2728.   }
  2729.   
  2730. - asm(".stabs \"_relalloc\",5,0,0,_realloc");
  2731. - 
  2732. - void * realloc(_r, n)
  2733. - void *_r;
  2734. - size_t n;
  2735. - {
  2736. -   struct mem_chunk *p, *q, *r = (struct mem_chunk *) _r;
  2737. -   long sz;
  2738. - 
  2739. - /* obscure features: realloc(NULL,n) is the same as malloc(n)
  2740. -  *               realloc(p, 0) is the same as free(p)
  2741. -  */
  2742. -   if (!r)
  2743. -     return malloc(n);
  2744. -   if (n == 0) {
  2745. -     free(_r);
  2746. -     return NULL;
  2747. -   }
  2748. -   p = r - 1;
  2749. -   sz = (n + sizeof(struct mem_chunk) + 7) & ~7;
  2750. - 
  2751. -   if (p->size > sz) 
  2752. -     {            /* block too big, split in two */
  2753. -     q = (struct mem_chunk * )(((long) p) + sz);
  2754. -     q->size = p->size - sz;
  2755. -         q->valid = VAL_ALLOC;
  2756. -     free(q + 1);
  2757. -     p->size = sz;
  2758. -     }
  2759. -     else 
  2760. -   if (p->size < sz)
  2761. -     {            /* block too small, get new one */
  2762. -     struct mem_chunk *s, *t;
  2763. -     q = &_mchunk_free_list;
  2764. -     t = _mchunk_free_list.next;
  2765. -     while (t != NULL && t < p)
  2766. -       {
  2767. -       q = t;
  2768. -       t = t->next;
  2769. -       }
  2770. - 
  2771. -     /* merge after if possible */
  2772. -     s = (struct mem_chunk * )(((long) p) + p->size);
  2773. -     if (t != NULL && s >= t && p->size + t->size >= sz)
  2774. -       {
  2775. -       assert(s == t);
  2776. -       p->size += t->size;
  2777. -       q->next = t->next;
  2778. -       t->size = 0;
  2779. -       t->next = NULL;
  2780. -       }
  2781. -     else
  2782. -       {
  2783. -       q = (struct mem_chunk * )malloc(n);
  2784. -       if (q != NULL)
  2785. -     {
  2786. -     n = p->size - sizeof(struct mem_chunk);
  2787. -     bcopy(r, q, n);
  2788. -         free(r);    /* free r only if we got a new block */
  2789. -         }
  2790. -       /* else we could try to mlalloc the rest and hope that we can merge */
  2791. -       r = q;
  2792. -     }
  2793. -   }
  2794. -   /* else current block will do just fine */
  2795. -   return((void * )r);
  2796. - }
  2797. - 
  2798. - asm(".stabs \"_clalloc\",5,0,0,_calloc");
  2799. - void * calloc(n, sz)
  2800. - size_t n, sz;
  2801. - {
  2802. -   void *r;
  2803. -   size_t total;
  2804. - 
  2805. -   total = n * sz;
  2806. -   if ((r = malloc(total)) != NULL)
  2807. -     {
  2808. -      bzero(r, total);
  2809. -     }
  2810. -   return(r);
  2811. - }
  2812. - 
  2813.   /*
  2814.    * Set zero block after malloc flag
  2815.    */
  2816. --- 182,187 ----
  2817. ***************
  2818. *** 284,286 ****
  2819. --- 199,209 ----
  2820.   {
  2821.       MAXHUNK = MINHUNK = siz;
  2822.   }
  2823. + 
  2824. + #ifndef __GNUC__
  2825. + void * malloc(n)
  2826. + size_t n; 
  2827. + {
  2828. +   return _malloc((unsigned long) n);
  2829. + }
  2830. + #endif
  2831. *** 1.12    1992/03/10 15:11:47
  2832. --- mktemp.c    1992/06/03 14:49:23
  2833. ***************
  2834. *** 11,18 ****
  2835.   #include <errno.h>
  2836.   #include "lib.h"
  2837.   
  2838. - #define __MINT__
  2839. - #include <mintbind.h>
  2840.   extern int __mint;        /* 0 for TOS, MiNT version number otherwise */
  2841.   
  2842.   #define TEN_MUL(X)    ((((X) << 2) + (X)) << 1)
  2843. --- 11,16 ----
  2844. ***************
  2845. *** 38,45 ****
  2846.     /* we need 5 X's for this: up to 3 for the pid, and up to 2 for the
  2847.        extra number */
  2848.     if (__mint && nx > 4 && startat < 256) {
  2849. !     int pid = Pgetpid();
  2850. !     (void) _itoa(pid, q, 10);
  2851.       while (*q) q++;
  2852.       (void) _itoa(startat++, q, 16);
  2853.       return pattern;
  2854. --- 36,42 ----
  2855.     /* we need 5 X's for this: up to 3 for the pid, and up to 2 for the
  2856.        extra number */
  2857.     if (__mint && nx > 4 && startat < 256) {
  2858. !     (void) _itoa(getpid(), q, 10);
  2859.       while (*q) q++;
  2860.       (void) _itoa(startat++, q, 16);
  2861.       return pattern;
  2862. *** 1.8    1991/06/11 14:56:53
  2863. --- perror.c    1992/06/03 14:49:24
  2864. ***************
  2865. *** 8,106 ****
  2866.   #include <errno.h>
  2867.   #include <string.h>
  2868.   
  2869. - 
  2870. - static char nullstr[] = "";
  2871. - 
  2872. - 
  2873. - char *sys_errlist[] =
  2874. -     {
  2875. -     "OK",                    /* 0 */
  2876. -     "error",                /* 1 */
  2877. -     "drive not ready",            /* 2 */
  2878. -     "unknown command",            /* 3 */
  2879. -     "crc error",                /* 4 */
  2880. -     "bad request",                /* 5 */
  2881. -     "seek error",                /* 6 */
  2882. -     "unknown media",            /* 7 */
  2883. -     "sector not found",            /* 8 */
  2884. -     "out of paper",                /* 9 */
  2885. -     "write failure",            /* 10 */
  2886. -     "read failure",                /* 11 */
  2887. -     "general mishap",                /* 12 */
  2888. -     "media write protected",        /* 13 */
  2889. -     "media changed",            /* 14 */
  2890. -     "unknown device",            /* 15 */
  2891. -     "bad sectors on format",        /* 16 */
  2892. -     "disk swap request",            /* 17 */
  2893. -     nullstr,                /* 18 */
  2894. -     nullstr,                /* 19 */
  2895. -     nullstr,                /* 20 */
  2896. -     nullstr,                /* 21 */
  2897. -     nullstr,                /* 22 */
  2898. -     nullstr,                /* 23 */
  2899. -     nullstr,                /* 24 */
  2900. -     nullstr,                /* 25 */
  2901. -     nullstr,                /* 26 */
  2902. -     nullstr,                /* 27 */
  2903. -     nullstr,                /* 28 */
  2904. -     nullstr,                /* 29 */
  2905. -     nullstr,                /* 30 */
  2906. -     nullstr,                /* 31 */
  2907. -     "invalid function number",        /* 32 */
  2908. -     "file not found",            /* 33 */
  2909. -     "path not found",            /* 34 */
  2910. -     "no more handles",            /* 35 */
  2911. -     "access denied",            /* 36 */
  2912. -     "invalid handle",            /* 37 */
  2913. -     nullstr,                /* 38 */
  2914. -     "out of memory",            /* 39 */
  2915. -     "invalid memory block",            /* 40 */
  2916. -     nullstr,                /* 41 */
  2917. -     nullstr,                /* 42 */
  2918. -     nullstr,                /* 43 */
  2919. -     nullstr,                /* 44 */
  2920. -     nullstr,                /* 45 */
  2921. -     "invalid drive id",            /* 46 */
  2922. -     nullstr,                /* 47 */
  2923. -     "rename across drives",            /* 48 */
  2924. -     "no more files",            /* 49 */
  2925. -     nullstr,                /* 50 */
  2926. -     nullstr,                /* 51 */
  2927. -     nullstr,                /* 52 */
  2928. -     nullstr,                /* 53 */
  2929. -     nullstr,                /* 54 */
  2930. -     nullstr,                /* 55 */
  2931. -     nullstr,                /* 56 */
  2932. -     nullstr,                /* 57 */
  2933. -     nullstr,                /* 58 */
  2934. -     nullstr,                /* 59 */
  2935. -     nullstr,                /* 60 */
  2936. -     nullstr,                /* 61 */
  2937. -     "domain error",                /* 62 */
  2938. -     "range error",                /* 63 */
  2939. -     "range error/bad argument",        /* 64 */
  2940. -     "internal error",            /* 65 */
  2941. -     "bad executable format",        /* 66 */
  2942. -     "memory block growth failure",        /* 67 */
  2943. -     nullstr,                /* 68 */
  2944. -     nullstr,                /* 69 */
  2945. -     nullstr,                /* 70 */
  2946. -     nullstr,                /* 71 */
  2947. -     nullstr,                /* 72 */
  2948. -     nullstr,                /* 73 */
  2949. -     nullstr,                /* 74 */
  2950. -     nullstr,                /* 75 */
  2951. -     nullstr,                /* 76 */
  2952. -     nullstr,                /* 77 */
  2953. -     nullstr,                /* 78 */
  2954. -     nullstr,                /* 79 */
  2955. -     "file already exists",            /* 80 */
  2956. -     "name too long",            /* 81 */
  2957. -     "not a tty",                /* 82 */
  2958. -     };
  2959. - 
  2960. - int    sys_nerr = (int)(sizeof(sys_errlist) / sizeof(sys_errlist[0]));
  2961. - 
  2962.   void perror(msg)
  2963.       const char *msg;
  2964.       {
  2965. --- 8,13 ----
  2966. ***************
  2967. *** 109,115 ****
  2968.           fputs(msg, stderr);
  2969.           fputs(": ", stderr);
  2970.           }
  2971. ! 
  2972. !     fputs(strerror(errno), stderr);
  2973.       fputs(".\n", stderr);
  2974.       }
  2975. --- 16,22 ----
  2976.           fputs(msg, stderr);
  2977.           fputs(": ", stderr);
  2978.           }
  2979. !     if(msg = strerror(errno))
  2980. !         fputs(msg, stderr);
  2981.       fputs(".\n", stderr);
  2982.       }
  2983. *** 1.4    1991/04/12 18:19:53
  2984. --- psignal.c    1992/06/03 14:49:24
  2985. ***************
  2986. *** 5,11 ****
  2987.     
  2988.   #include <signal.h>
  2989.   #include <siglist.h>
  2990. - #include <unistd.h>
  2991.   #include <string.h>
  2992.   #include "lib.h"
  2993.     
  2994. --- 5,10 ----
  2995. ***************
  2996. *** 14,27 ****
  2997.       int  sig;
  2998.       const char *prefix;
  2999.   {
  3000. !     write(2, "\r\n", 2);
  3001.       if(prefix && *prefix) {
  3002. !       write(2, prefix, strlen(prefix));
  3003. !       write(2, ": ", 2);
  3004.       }
  3005.       if (sig > 0 && sig < NSIG)
  3006. !       write(2, sys_siglist[sig], (int)strlen(sys_siglist[sig]));
  3007.        else
  3008. !       write(2, "unknown signal", 14);
  3009. !     write(2, "\r\n", 2);
  3010.   }
  3011. --- 13,26 ----
  3012.       int  sig;
  3013.       const char *prefix;
  3014.   {
  3015. !     _write(2, "\r\n", 2L);
  3016.       if(prefix && *prefix) {
  3017. !       _write(2, prefix, (long)strlen(prefix));
  3018. !       _write(2, ": ", 2L);
  3019.       }
  3020.       if (sig > 0 && sig < NSIG)
  3021. !       _write(2, sys_siglist[sig], (long)strlen(sys_siglist[sig]));
  3022.        else
  3023. !       _write(2, "unknown signal", 14L);
  3024. !     _write(2, "\r\n", 2L);
  3025.   }
  3026. *** 1.11    1992/03/06 19:19:47
  3027. --- qsort.c    1992/06/03 14:49:25
  3028. ***************
  3029. *** 50,59 ****
  3030.   #define STACK_NOT_EMPTY \
  3031.       (stack < top)                
  3032.   
  3033. ! static void swap __PROTO((unsigned char *, unsigned char *, size_t));
  3034. ! static void Move __PROTO((unsigned char *, unsigned char *, size_t));
  3035. ! static void insert_sort __PROTO((void *, void *, size_t, int (*)(const void *, const void *)));
  3036. ! static void *find_pivot __PROTO((void *, void *, size_t, int (*)(const void *, const void *)));
  3037.   
  3038.   /* Discontinue quicksort algorithm when partition gets below this size. */
  3039.   
  3040. --- 50,59 ----
  3041.   #define STACK_NOT_EMPTY \
  3042.       (stack < top)                
  3043.   
  3044. ! INLINE static void swap __PROTO((unsigned char *, unsigned char *, size_t));
  3045. ! INLINE static void Move __PROTO((unsigned char *, unsigned char *, size_t));
  3046. ! INLINE static void insert_sort __PROTO((void *, void *, size_t, int (*)(const void *, const void *)));
  3047. ! INLINE static void *find_pivot __PROTO((void *, void *, size_t, int (*)(const void *, const void *)));
  3048.   
  3049.   /* Discontinue quicksort algorithm when partition gets below this size. */
  3050.   
  3051. *** 1.6    1992/03/06 19:19:47
  3052. --- random.c    1992/06/03 14:49:25
  3053. ***************
  3054. *** 39,45 ****
  3055.    * zeroeth element of the array is the type of R.N.G. being used (small
  3056.    * integer); the remainder of the array is the state information for the
  3057.    * R.N.G.  Thus, 32 bytes of state information will give 7 longs worth of
  3058. !  * state information, which will allow a degree seven polynomial.  (Note: the 
  3059.    * zeroeth word of state information also has some other information stored
  3060.    * in it -- see setstate() for details).
  3061.    * The random number generation technique is a linear feedback shift register
  3062. --- 39,45 ----
  3063.    * zeroeth element of the array is the type of R.N.G. being used (small
  3064.    * integer); the remainder of the array is the state information for the
  3065.    * R.N.G.  Thus, 32 bytes of state information will give 7 longs worth of
  3066. !  * state information, which will allow a degree seven polynomial.  (Note: the
  3067.    * zeroeth word of state information also has some other information stored
  3068.    * in it -- see setstate() for details).
  3069.    * The random number generation technique is a linear feedback shift register
  3070. ***************
  3071. *** 121,133 ****
  3072.    */
  3073.   
  3074.   static  long        randtbl[ DEG_3 + 1 ]    = { TYPE_3,
  3075. !                 0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342, 
  3076. !                 0xde3b81e0, 0xdf0a6fb5, 0xf103bc02, 0x48f340fb, 
  3077. !                 0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd, 
  3078. !                 0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86, 
  3079. !                 0xda672e2a, 0x1588ca88, 0xe369735d, 0x904f35f7, 
  3080. !                 0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc, 
  3081. !                 0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b, 
  3082.                       0xf5ad9d0e, 0x8999220b, 0x27fb47b9 };
  3083.   
  3084.   /*
  3085. --- 121,133 ----
  3086.    */
  3087.   
  3088.   static  long        randtbl[ DEG_3 + 1 ]    = { TYPE_3,
  3089. !                 0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342,
  3090. !                 0xde3b81e0, 0xdf0a6fb5, 0xf103bc02, 0x48f340fb,
  3091. !                 0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd,
  3092. !                 0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86,
  3093. !                 0xda672e2a, 0x1588ca88, 0xe369735d, 0x904f35f7,
  3094. !                 0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc,
  3095. !                 0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b,
  3096.                       0xf5ad9d0e, 0x8999220b, 0x27fb47b9 };
  3097.   
  3098.   /*
  3099. ***************
  3100. *** 182,198 ****
  3101.    * values produced by this routine.
  3102.    */
  3103.   
  3104. ! void srandom( x )
  3105.   
  3106. !     unsigned int x;
  3107.   {
  3108. !         register  int        i;
  3109. !     long random(void);
  3110.   
  3111.       if(  rand_type  ==  TYPE_0  )  {
  3112.           state[ 0 ] = x;
  3113.       }
  3114.       else  {
  3115.           state[ 0 ] = x;
  3116.           for( i = 1; i < rand_deg; i++ )  {
  3117.           state[i] = 1103515245*state[i - 1] + 12345;
  3118. --- 182,200 ----
  3119.    * values produced by this routine.
  3120.    */
  3121.   
  3122. ! void            /* ++ERS: Berkeley didn't have this */
  3123. ! srandom( x )
  3124.   
  3125. !     unsigned        x;
  3126.   {
  3127. !         register  int        i, j;
  3128. !     long random();
  3129.   
  3130.       if(  rand_type  ==  TYPE_0  )  {
  3131.           state[ 0 ] = x;
  3132.       }
  3133.       else  {
  3134. +         j = 1;
  3135.           state[ 0 ] = x;
  3136.           for( i = 1; i < rand_deg; i++ )  {
  3137.           state[i] = 1103515245*state[i - 1] + 12345;
  3138. ***************
  3139. *** 221,237 ****
  3140.    * Returns a pointer to the old state.
  3141.    */
  3142.   
  3143. - #if !__STDC__
  3144. -    /* you need an ansi C compatible pre-processor jack! */
  3145. - #else
  3146. - #  define STR(s) # s
  3147. - #  define XSTR(s) STR(s)
  3148. - #endif
  3149. - 
  3150.   char  *
  3151.   initstate( seed, arg_state, n )
  3152.   
  3153. !     unsigned int    seed;            /* seed for R. N. G. */
  3154.       char        *arg_state;        /* pointer to state array */
  3155.       int            n;            /* # bytes of state info */
  3156.   {
  3157. --- 223,232 ----
  3158.    * Returns a pointer to the old state.
  3159.    */
  3160.   
  3161.   char  *
  3162.   initstate( seed, arg_state, n )
  3163.   
  3164. !     unsigned        seed;            /* seed for R. N. G. */
  3165.       char        *arg_state;        /* pointer to state array */
  3166.       int            n;            /* # bytes of state info */
  3167.   {
  3168. ***************
  3169. *** 241,252 ****
  3170.       else  state[ -1 ] = MAX_TYPES*(rptr - state) + rand_type;
  3171.       if(  n  <  BREAK_1  )  {
  3172.           if(  n  <  BREAK_0  )  {
  3173. - /*
  3174.           fprintf( stderr, "initstate: not enough state (%d bytes) with which to do jack; ignored.\n", n );
  3175. ! */
  3176. !         fputs( "initstate: not enough state (less than " XSTR(BREAK_0)
  3177. !               " bytes)\nwith which to do jack; ignored.\n", stderr);
  3178. !         return NULL;
  3179.           }
  3180.           rand_type = TYPE_0;
  3181.           rand_deg = DEG_0;
  3182. --- 236,243 ----
  3183.       else  state[ -1 ] = MAX_TYPES*(rptr - state) + rand_type;
  3184.       if(  n  <  BREAK_1  )  {
  3185.           if(  n  <  BREAK_0  )  {
  3186.           fprintf( stderr, "initstate: not enough state (%d bytes) with which to do jack; ignored.\n", n );
  3187. !         return 0;
  3188.           }
  3189.           rand_type = TYPE_0;
  3190.           rand_deg = DEG_0;
  3191. ***************
  3192. *** 324,335 ****
  3193.           break;
  3194.   
  3195.           default:
  3196. - /**
  3197.           fprintf( stderr, "setstate: state info has been munged; not changed.\n" );
  3198. - **/
  3199. -         fputs("setstate: state info has been munged; not changed.\n",
  3200. -               stderr);
  3201. -         
  3202.       }
  3203.       state = &new_state[ 1 ];
  3204.       if(  rand_type  !=  TYPE_0  )  {
  3205. --- 315,321 ----
  3206. ***************
  3207. *** 361,367 ****
  3208.   random()
  3209.   {
  3210.       long        i;
  3211. !     
  3212.       if(  rand_type  ==  TYPE_0  )  {
  3213.           i = state[0] = ( state[0]*1103515245 + 12345 )&0x7fffffff;
  3214.       }
  3215. --- 347,353 ----
  3216.   random()
  3217.   {
  3218.       long        i;
  3219. ! 
  3220.       if(  rand_type  ==  TYPE_0  )  {
  3221.           i = state[0] = ( state[0]*1103515245 + 12345 )&0x7fffffff;
  3222.       }
  3223. ***************
  3224. *** 378,381 ****
  3225.       }
  3226.       return( i );
  3227.   }
  3228. - 
  3229. --- 364,366 ----
  3230. *** 1.11    1992/04/06 19:33:32
  3231. --- sbrk.c    1992/06/03 14:49:26
  3232. ***************
  3233. *** 15,20 ****
  3234. --- 15,26 ----
  3235.      brain damage, even when pointed out to them. sigh!)
  3236.   */
  3237.   
  3238. + /*
  3239. +  * support heat and serve C -- whose author continues to be adamant about
  3240. +  * size_t -- big sigh!
  3241. +  */
  3242. + 
  3243. + #include <stddef.h>
  3244.   #include <osbind.h>
  3245.   #include <unistd.h>
  3246.   #include <errno.h>
  3247. ***************
  3248. *** 24,36 ****
  3249.   extern short _split_mem;
  3250.   
  3251.   static void * HeapAlloc( sz )
  3252. ! size_t sz ;
  3253.   {
  3254.       char slush [64];
  3255.       register void *sp;
  3256.       
  3257.       sp = (void *)slush;
  3258. !     sz = (sz + 7) & ~((size_t)7L); /* round up request size next octet */
  3259.   
  3260.       if ( sp < (void *)((char *)_heapbase + sz) )
  3261.       {
  3262. --- 30,42 ----
  3263.   extern short _split_mem;
  3264.   
  3265.   static void * HeapAlloc( sz )
  3266. ! unsigned long sz ;
  3267.   {
  3268.       char slush [64];
  3269.       register void *sp;
  3270.       
  3271.       sp = (void *)slush;
  3272. !     sz = (sz + 7) & ~((unsigned long)7L); /* round up request size next octet */
  3273.   
  3274.       if ( sp < (void *)((char *)_heapbase + sz) )
  3275.       {
  3276. ***************
  3277. *** 43,52 ****
  3278.       return( sp );
  3279.   }
  3280.   
  3281. ! asm(".stabs \"_sbrk\",5,0,0,_lsbrk"); /* dept of clean tricks */
  3282.   
  3283.   /* provided for compilers with sizeof(int) == 2 */
  3284. ! void *lsbrk(long n)
  3285.   {
  3286.     void *rval;
  3287.   
  3288. --- 49,62 ----
  3289.       return( sp );
  3290.   }
  3291.   
  3292. ! #ifndef __GNUC__
  3293. ! asm(".stabs \"_sbrk\",5,0,0,__sbrk"); /* dept of clean tricks */
  3294. ! asm(".stabs \"_lsbrk\",5,0,0,__sbrk"); /* dept of clean tricks */
  3295. ! #endif
  3296.   
  3297.   /* provided for compilers with sizeof(int) == 2 */
  3298. ! void *_sbrk(n)
  3299. ! long n;
  3300.   {
  3301.     void *rval;
  3302.   
  3303. ***************
  3304. *** 64,70 ****
  3305.         if(_split_mem)
  3306.         {  /* now switch over to own heap for further requests, including this one */
  3307.         _split_mem = 0;
  3308. !       return lsbrk(n);
  3309.         }
  3310.         errno = ENOMEM;
  3311.         rval = (void *)(-1L);
  3312. --- 74,80 ----
  3313.         if(_split_mem)
  3314.         {  /* now switch over to own heap for further requests, including this one */
  3315.         _split_mem = 0;
  3316. !       return _sbrk(n);
  3317.         }
  3318.         errno = ENOMEM;
  3319.         rval = (void *)(-1L);
  3320. ***************
  3321. *** 71,73 ****
  3322. --- 81,97 ----
  3323.     }
  3324.     return rval;
  3325.   }
  3326. + 
  3327. + #ifndef __GNUC__
  3328. + void *sbrk(x)
  3329. + int x;
  3330. + {
  3331. +     return _sbrk((long)x);
  3332. + }
  3333. + 
  3334. + void *lsbrk(x)
  3335. + long x;
  3336. + {
  3337. +     return _sbrk(x);
  3338. + }
  3339. + #endif
  3340. *** 1.8    1991/05/23 14:43:17
  3341. --- setbuf.c    1992/06/03 14:49:26
  3342. ***************
  3343. *** 35,42 ****
  3344.    * should stream be flushed before change?? i think so.
  3345.    *    ++jrb
  3346.    */
  3347. - #define __SRC__
  3348. - #include <unistd.h>
  3349.   
  3350.   void setlinebuf(fp)
  3351.   register FILE *fp;
  3352. --- 35,40 ----
  3353. *** 1.2    1991/04/12 18:19:53
  3354. --- sgtty.c    1992/06/03 14:49:27
  3355. ***************
  3356. *** 3,9 ****
  3357.    */
  3358.   
  3359.   #include <ioctl.h>
  3360. - #include <unistd.h>
  3361.   
  3362.   int
  3363.   stty(fd, _tty)
  3364. --- 3,8 ----
  3365. *** 1.7    1992/03/06 19:19:47
  3366. --- sprintf.c    1992/06/03 14:49:27
  3367. ***************
  3368. *** 1,6 ****
  3369. --- 1,7 ----
  3370.   #include <stdarg.h>
  3371.   #include <stdio.h>
  3372.   #include <limits.h>
  3373. + #include "lib.h"
  3374.   
  3375.   #ifdef __SOZOBON__    /* Electronic brain... */
  3376.   static FILE dummyf =
  3377. *** 1.7    1991/06/23 17:07:09
  3378. --- strchr.c    1992/06/03 14:49:28
  3379. ***************
  3380. *** 5,11 ****
  3381. --- 5,21 ----
  3382.   /*
  3383.    * strchr - find first occurrence of a character in a string
  3384.    */
  3385. + #ifdef __GNUC__
  3386.   asm(".stabs \"_index\",5,0,0,_strchr"); /* dept of clean tricks */
  3387. + #else
  3388. + char *
  3389. + index(s, charwanted)
  3390. +       const char *s;
  3391. +       char charwanted;
  3392. + {
  3393. +       return strchr(s, charwanted);
  3394. + }
  3395. + #endif
  3396.   
  3397.   char *                /* found char, or NULL if none */
  3398.   strchr(s, charwanted)
  3399. *** 1.4    1991/05/23 14:43:17
  3400. --- strerror.c    1992/06/03 14:49:29
  3401. ***************
  3402. *** 1,6 ****
  3403. --- 1,104 ----
  3404.   /* from Henry Spencer's stringlib */
  3405.   #include <string.h>
  3406.   
  3407. + static char nullstr[] = "unknown error";
  3408. + 
  3409. + char *sys_errlist[] =
  3410. +     {
  3411. +     "OK",                    /* 0 */
  3412. +     "error",                /* 1 */
  3413. +     "drive not ready",            /* 2 */
  3414. +     "unknown command",            /* 3 */
  3415. +     "crc error",                /* 4 */
  3416. +     "bad request",                /* 5 */
  3417. +     "seek error",                /* 6 */
  3418. +     "unknown media",            /* 7 */
  3419. +     "sector not found",            /* 8 */
  3420. +     "out of paper",                /* 9 */
  3421. +     "write failure",            /* 10 */
  3422. +     "read failure",                /* 11 */
  3423. +     "general mishap",            /* 12 */
  3424. +     "media write protected",        /* 13 */
  3425. +     "media changed",            /* 14 */
  3426. +     "unknown device",            /* 15 */
  3427. +     "bad sectors on format",        /* 16 */
  3428. +     "disk swap request",            /* 17 */
  3429. +     nullstr,                /* 18 */
  3430. +     nullstr,                /* 19 */
  3431. +     nullstr,                /* 20 */
  3432. +     nullstr,                /* 21 */
  3433. +     nullstr,                /* 22 */
  3434. +     nullstr,                /* 23 */
  3435. +     nullstr,                /* 24 */
  3436. +     nullstr,                /* 25 */
  3437. +     nullstr,                /* 26 */
  3438. +     nullstr,                /* 27 */
  3439. +     nullstr,                /* 28 */
  3440. +     nullstr,                /* 29 */
  3441. +     nullstr,                /* 30 */
  3442. +     nullstr,                /* 31 */
  3443. +     "invalid function number",        /* 32 */
  3444. +     "file not found",            /* 33 */
  3445. +     "path not found",            /* 34 */
  3446. +     "no more handles",            /* 35 */
  3447. +     "access denied",            /* 36 */
  3448. +     "invalid handle",            /* 37 */
  3449. +     nullstr,                /* 38 */
  3450. +     "out of memory",            /* 39 */
  3451. +     "invalid memory block",            /* 40 */
  3452. +     nullstr,                /* 41 */
  3453. +     nullstr,                /* 42 */
  3454. +     nullstr,                /* 43 */
  3455. +     nullstr,                /* 44 */
  3456. +     nullstr,                /* 45 */
  3457. +     "invalid drive id",            /* 46 */
  3458. +     nullstr,                /* 47 */
  3459. +     "rename across drives",            /* 48 */
  3460. +     "no more files",            /* 49 */
  3461. +     nullstr,                /* 50 */
  3462. +     nullstr,                /* 51 */
  3463. +     nullstr,                /* 52 */
  3464. +     nullstr,                /* 53 */
  3465. +     nullstr,                /* 54 */
  3466. +     nullstr,                /* 55 */
  3467. +     nullstr,                /* 56 */
  3468. +     nullstr,                /* 57 */
  3469. +     nullstr,                /* 58 */
  3470. +     nullstr,                /* 59 */
  3471. +     nullstr,                /* 60 */
  3472. +     nullstr,                /* 61 */
  3473. +     nullstr,                /* 62 */
  3474. +     nullstr,                /* 63 */
  3475. +     "range error/bad argument",        /* 64 */
  3476. +     "internal error",            /* 65 */
  3477. +     "bad executable format",        /* 66 */
  3478. +     "memory block growth failure",        /* 67 */
  3479. +     nullstr,                /* 68 */
  3480. +     nullstr,                /* 69 */
  3481. +     nullstr,                /* 70 */
  3482. +     nullstr,                /* 71 */
  3483. +     nullstr,                /* 72 */
  3484. +     nullstr,                /* 73 */
  3485. +     nullstr,                /* 74 */
  3486. +     nullstr,                /* 75 */
  3487. +     nullstr,                /* 76 */
  3488. +     nullstr,                /* 77 */
  3489. +     nullstr,                /* 78 */
  3490. +     nullstr,                /* 79 */
  3491. +     "too many symbolic links",        /* 80 */
  3492. +     nullstr,                /* 81 */
  3493. +     nullstr,                /* 82 */
  3494. +     nullstr,                /* 83 */
  3495. +     nullstr,                /* 84 */
  3496. +     "file already exists",            /* 85 */
  3497. +     "name too long",            /* 86 */
  3498. +     "not a tty",                /* 87 */
  3499. +     "range error",                /* 88 */
  3500. +     "domain error"                /* 89 */
  3501. +     };
  3502. + 
  3503. + int    sys_nerr = (int)(sizeof(sys_errlist)/sizeof(sys_errlist[0]));
  3504. + 
  3505.   /*
  3506.    * strerror - map error number to descriptive string
  3507.    *
  3508. ***************
  3509. *** 16,20 ****
  3510.       if (errnum >= 0 && errnum < sys_nerr)
  3511.           return(sys_errlist[errnum]);
  3512.       else
  3513. !         return("unknown error");
  3514.   }
  3515. --- 114,118 ----
  3516.       if (errnum >= 0 && errnum < sys_nerr)
  3517.           return(sys_errlist[errnum]);
  3518.       else
  3519. !         return(nullstr);
  3520.   }
  3521. *** 1.5    1992/04/13 15:50:45
  3522. --- strftime.c    1992/06/03 14:49:29
  3523. ***************
  3524. *** 196,205 ****
  3525.               strftime(buf, sizeof buf, "%H:%M:%S", ts);
  3526.               break;
  3527.   #endif
  3528. -            default:
  3529. -             buf[0] = q;
  3530. -             buf[1] = 0;
  3531. -             break;
  3532.                   }
  3533.   
  3534.                   if (num + (len = strlen(putstr)) >= maxsize)
  3535. --- 196,201 ----
  3536. *** 1.5    1991/04/12 18:19:53
  3537. --- strlen.c    1992/06/03 14:49:29
  3538. ***************
  3539. *** 13,18 ****
  3540.   
  3541.       if (!scan) return 0;
  3542.       while (*scan++ != '\0')
  3543. !         continue;
  3544.       return (size_t)((long)scan - (long)start);
  3545.   }
  3546. --- 13,18 ----
  3547.   
  3548.       if (!scan) return 0;
  3549.       while (*scan++ != '\0')
  3550. !         continue;
  3551.       return (size_t)((long)scan - (long)start);
  3552.   }
  3553. *** 1.7    1991/06/23 17:07:09
  3554. --- strrchr.c    1992/06/03 14:49:31
  3555. ***************
  3556. *** 4,10 ****
  3557. --- 4,20 ----
  3558.   /*
  3559.    * strrchr - find last occurrence of a character in a string
  3560.    */
  3561. + #ifdef __GNUC__
  3562.   asm(".stabs \"_rindex\",5,0,0,_strrchr"); /* dept of clean tricks */
  3563. + #else
  3564. + char *
  3565. + rindex(s, charwanted)
  3566. +       const char *s;
  3567. +       char charwanted;
  3568. + {
  3569. +       return strrchr(s, charwanted);
  3570. + }
  3571. + #endif
  3572.   
  3573.   char *                /* found char, or NULL if none */
  3574.   strrchr(s, charwanted)
  3575. *** 1.16    1992/04/06 19:33:32
  3576. --- system.c    1992/06/03 14:49:32
  3577. ***************
  3578. *** 3,9 ****
  3579.    *
  3580.    * Written by Eric R. Smith and placed in the public domain.
  3581.    *
  3582. !  * Modified by Allan Pratt to call unx2dos on redirect file names
  3583.    * and to call spawnvp() without calling fork() -- why bother?
  3584.    *
  3585.    * Modified by Frank Ridderbusch in _parseargs() to handle the case
  3586. --- 3,9 ----
  3587.    *
  3588.    * Written by Eric R. Smith and placed in the public domain.
  3589.    *
  3590. !  * Modified by Allan Pratt to call _unx2dos on redirect file names
  3591.    * and to call spawnvp() without calling fork() -- why bother?
  3592.    *
  3593.    * Modified by Frank Ridderbusch in _parseargs() to handle the case
  3594. ***************
  3595. *** 12,18 ****
  3596.    *
  3597.    */
  3598.   
  3599. ! #include <stdio.h>
  3600.   #include <string.h>
  3601.   #include <ctype.h>
  3602.   #include <stdlib.h>
  3603. --- 12,18 ----
  3604.    *
  3605.    */
  3606.   
  3607. ! #include <limits.h>
  3608.   #include <string.h>
  3609.   #include <ctype.h>
  3610.   #include <stdlib.h>
  3611. ***************
  3612. *** 23,34 ****
  3613.   #include <unistd.h>
  3614.   #include "lib.h"
  3615.   
  3616. - #ifndef _COMPILER_H
  3617. - #include <compiler.h>
  3618. - #endif
  3619. - 
  3620.   #define isquote(c) ((c) == '\"' || (c) == '\'' || (c) == '`')
  3621. ! #define ARG_ERR       ( (Argentry *) -1L )
  3622.   
  3623.   /* struct. used to build a list of arguments for the command */
  3624.   
  3625. --- 23,30 ----
  3626.   #include <unistd.h>
  3627.   #include "lib.h"
  3628.   
  3629.   #define isquote(c) ((c) == '\"' || (c) == '\'' || (c) == '`')
  3630. ! #define ARG_ERR       ( (Argentry *) -1 )
  3631.   
  3632.   /* struct. used to build a list of arguments for the command */
  3633.   
  3634. ***************
  3635. *** 37,45 ****
  3636.       char    string[1];
  3637.   } Argentry;
  3638.   
  3639. - static Argentry *_argalloc __PROTO((const char *s));
  3640. - static void _argfree __PROTO((Argentry *p));
  3641. - static Argentry *_parseargs __PROTO((const char *s));
  3642.   
  3643.   /* allocate an Argentry that will hold the string "s" */
  3644.   
  3645. --- 33,38 ----
  3646. ***************
  3647. *** 82,92 ****
  3648.       const char *s;
  3649.   {
  3650.       Argentry *cur, *res;
  3651. - #ifdef __SOZOBON__        /* This is actually the legal way, */
  3652.       char buf[1024];
  3653. - #else
  3654. -     char buf[BUFSIZ];    /* because this features a cast. */
  3655. - #endif
  3656.       char *t, quote;
  3657.   
  3658.       res = cur = _argalloc("");
  3659. --- 75,81 ----
  3660. ***************
  3661. *** 136,142 ****
  3662.       char *infile, *outfile;
  3663.       int  infd = 0, outfd = 1, append = 0;
  3664.       int oldin = 0, oldout = 1;    /* hold the Fdup'd in, out */
  3665. !     char path[FILENAME_MAX];
  3666.       int retval;
  3667.   
  3668.       if (!s)        /* check for system() supported ?? */
  3669. --- 125,131 ----
  3670.       char *infile, *outfile;
  3671.       int  infd = 0, outfd = 1, append = 0;
  3672.       int oldin = 0, oldout = 1;    /* hold the Fdup'd in, out */
  3673. !     char path[PATH_MAX];
  3674.       int retval;
  3675.   
  3676.       if (!s)        /* check for system() supported ?? */
  3677. *** 1.4    1991/04/12 18:19:53
  3678. --- time.c    1992/06/03 14:49:33
  3679. ***************
  3680. *** 3,18 ****
  3681.   
  3682.   #include <time.h>
  3683.   #include <osbind.h>
  3684. - #include <unistd.h>
  3685.   
  3686.   static struct tm this_tm;
  3687.   
  3688.   /* unixtime: convert a DOS time/date pair into a unix time */
  3689.   
  3690. ! time_t unixtime(dostime, dosdate)
  3691.       unsigned dostime, dosdate;
  3692.   {
  3693. !     extern time_t mktime(const struct tm *);
  3694.       struct tm *stm = &this_tm;
  3695.   
  3696.       stm->tm_sec = (dostime & 31) << 1;
  3697. --- 3,23 ----
  3698.   
  3699.   #include <time.h>
  3700.   #include <osbind.h>
  3701.   
  3702.   static struct tm this_tm;
  3703. + int _dst;
  3704.   
  3705.   /* unixtime: convert a DOS time/date pair into a unix time */
  3706. + /* in case people were wondering about whether or not DST is applicable
  3707. +  * right now, we set the external variable _dst to the value
  3708. +  * returned from mktime
  3709. +  */
  3710.   
  3711. ! time_t 
  3712. ! _unixtime(dostime, dosdate)
  3713.       unsigned dostime, dosdate;
  3714.   {
  3715. !     time_t t;
  3716.       struct tm *stm = &this_tm;
  3717.   
  3718.       stm->tm_sec = (dostime & 31) << 1;
  3719. ***************
  3720. *** 21,29 ****
  3721.       stm->tm_mday = dosdate & 31;
  3722.       stm->tm_mon = ((dosdate >> 5) & 15) - 1;
  3723.       stm->tm_year = 80 + ((dosdate >> 9) & 255);
  3724.   
  3725. ! /* mktime expects a local time */
  3726. !     return mktime(stm);
  3727.   }
  3728.   
  3729.   time_t time(t)
  3730. --- 26,39 ----
  3731.       stm->tm_mday = dosdate & 31;
  3732.       stm->tm_mon = ((dosdate >> 5) & 15) - 1;
  3733.       stm->tm_year = 80 + ((dosdate >> 9) & 255);
  3734. +     stm->tm_isdst = -1;    /* we don't know about DST */
  3735. +     stm->tm_wday = stm->tm_yday = -1; /* or about these */
  3736.   
  3737. ! /* mktime expects a local time, which is what we're giving it */
  3738. !     t = mktime(stm);
  3739. ! 
  3740. !     _dst = (stm->tm_isdst == 1) ? 1 : 0;
  3741. !     return t;
  3742.   }
  3743.   
  3744.   time_t time(t)
  3745. ***************
  3746. *** 34,42 ****
  3747.   
  3748.       dostime = Tgettime();
  3749.       dosdate = Tgetdate();
  3750. !     made = unixtime(dostime, dosdate);
  3751.       if (t)
  3752.           *t = made;
  3753.       return made;
  3754.   }
  3755. - 
  3756. --- 44,51 ----
  3757.   
  3758.       dostime = Tgettime();
  3759.       dosdate = Tgetdate();
  3760. !     made = _unixtime(dostime, dosdate);
  3761.       if (t)
  3762.           *t = made;
  3763.       return made;
  3764.   }
  3765. *** 1.2    1989/07/17 02:24:36
  3766. --- tmpfile.c    1992/06/03 14:49:33
  3767. ***************
  3768. *** 6,11 ****
  3769. --- 6,13 ----
  3770.   #include <stdio.h>
  3771.   #include <stdlib.h>
  3772.   
  3773. + extern int __mint;
  3774. + 
  3775.   typedef struct {
  3776.       char    *name;
  3777.       FILE    *fp;
  3778. ***************
  3779. *** 37,42 ****
  3780. --- 39,54 ----
  3781.               free(junknam);
  3782.           return NULL;
  3783.       }
  3784. + 
  3785. + /* in MiNT 0.9 and above, we can often unlink a file and continue to use
  3786. +  * it; some file systems may return EACCDN for unlinking an open file,
  3787. +  * in which case we use the old method of unlinking the file at exit
  3788. +  */
  3789. +     if (__mint >= 9) {
  3790. +         if (remove(junknam) == 0)
  3791. +             return junkfil;
  3792. +     }
  3793. + 
  3794.       if((++numtmps) == 0)
  3795.           file_to_delete = (FILE_RECORD *)malloc((size_t)sizeof(FILE_RECORD));
  3796.       else
  3797. *** 1.7    1992/03/06 19:19:47
  3798. --- tmpnam.c    1992/06/03 14:49:34
  3799. ***************
  3800. *** 1,27 ****
  3801.   /* tmpnam.c : return a temporary file name */
  3802.   /* written by Eric R. Smith and placed in the public domain */
  3803. ! 
  3804.   #include <stdio.h>
  3805.   #include <stdlib.h>
  3806.   #include <string.h>
  3807.   
  3808. ! extern char *getenv(const char *), *mktemp(char *), *strcpy(char *, const char *),
  3809. !  *strcat(char *, const char *);
  3810.   
  3811.   char *tmpnam(buf)
  3812.       char *buf;
  3813.   {
  3814.       char *tmpdir;
  3815. ! 
  3816. !     if (!buf && !(buf = (char *)malloc(L_tmpnam)))
  3817. !         return NULL;
  3818.   
  3819. !     if (!(tmpdir = getenv("TEMP")) && !(tmpdir = getenv("TMPDIR")))
  3820. ! #ifdef UNIX
  3821. !         tmpdir = "/tmp";
  3822. ! #else
  3823.           tmpdir = ".";
  3824. ! #endif
  3825. !     (void) strcat(strcpy(buf, tmpdir), "\\__XXXXXX");
  3826.       return(mktemp(buf));
  3827.   }
  3828. --- 1,40 ----
  3829.   /* tmpnam.c : return a temporary file name */
  3830.   /* written by Eric R. Smith and placed in the public domain */
  3831. ! /**
  3832. !  *  - retuned name can be passed outside via system(); other programs
  3833. !  *    may not dig '/' as a path separator
  3834. !  *  - somehow more frugal in a memory use
  3835. !  *    (mj - October 1990)
  3836. !  **/
  3837.   #include <stdio.h>
  3838.   #include <stdlib.h>
  3839.   #include <string.h>
  3840.   
  3841. ! static char pattern[] = "\\__XXXXXX";
  3842.   
  3843.   char *tmpnam(buf)
  3844.       char *buf;
  3845.   {
  3846.       char *tmpdir;
  3847. !     size_t tlen;
  3848. !     extern char *mktemp __PROTO((char *));
  3849.   
  3850. !     if (!(tmpdir = getenv("TEMP")) && !(tmpdir = getenv("TMPDIR")) &&
  3851. !         !(tmpdir = getenv("TMP")) && !(tmpdir = getenv("TEMPDIR")))
  3852.           tmpdir = ".";
  3853. ! 
  3854. !     tlen = strlen(tmpdir);
  3855. ! 
  3856. !     if (!buf) {
  3857. !         size_t blen;
  3858. !         
  3859. !         blen = tlen + sizeof(pattern);
  3860. !         if (NULL == (buf = (char *) malloc(blen)))
  3861. !             return NULL;
  3862. !     }
  3863. !     strcpy(buf, tmpdir);
  3864. !     if (tmpdir[tlen-1] == '/' || tmpdir[tlen-1] == '\\')
  3865. !         --tlen;
  3866. !     strcpy(buf+tlen, pattern);
  3867.       return(mktemp(buf));
  3868.   }
  3869. *** 1.8    1991/06/11 23:04:27
  3870. --- utime.c    1992/06/03 14:49:34
  3871. ***************
  3872. *** 11,19 ****
  3873.    *
  3874.    */
  3875.   
  3876. ! #include <stdio.h>
  3877. ! #include <unistd.h>
  3878. ! #include <support.h>
  3879.   #include <errno.h>
  3880.   #include <osbind.h>
  3881.   #include <assert.h>
  3882. --- 11,19 ----
  3883.    *
  3884.    */
  3885.   
  3886. ! #include <limits.h>
  3887. ! #include <sys/types.h>
  3888. ! #include <time.h>
  3889.   #include <errno.h>
  3890.   #include <osbind.h>
  3891.   #include <assert.h>
  3892. ***************
  3893. *** 25,31 ****
  3894.   time_t dostime(t)
  3895.       time_t t;
  3896.   {
  3897. !       time_t time, date;
  3898.       struct tm *ctm;
  3899.   
  3900.       if (!(ctm = localtime(&t)))
  3901. --- 25,31 ----
  3902.   time_t dostime(t)
  3903.       time_t t;
  3904.   {
  3905. !         time_t time, date;
  3906.       struct tm *ctm;
  3907.   
  3908.       if (!(ctm = localtime(&t)))
  3909. ***************
  3910. *** 44,50 ****
  3911.       int fh;
  3912.       time_t settime;
  3913.       unsigned long dtime;    /* dos time equivalent */
  3914. !     char filename[FILENAME_MAX];
  3915.   
  3916.       if (tset)
  3917.           settime = tset->modtime;
  3918. --- 44,50 ----
  3919.       int fh;
  3920.       time_t settime;
  3921.       unsigned long dtime;    /* dos time equivalent */
  3922. !     char filename[PATH_MAX];
  3923.   
  3924.       if (tset)
  3925.           settime = tset->modtime;
  3926.